字索引压缩

// 索引压缩、解压类 Powered by barenx

#pragma  once

class  IndexZip
... {
public:
    long *_lbuf;
    short *_sbuf;
    //all size def by byte
    unsigned long _intSize;
    unsigned long _lbuf_InUse;
    unsigned long _sbuf_InUse;
    unsigned long  _lCache_Size;
    unsigned long  _sCache_Size;

    IndexZip(unsigned long  m_cache_set)
    ...{
        _intSize=_sCache_Size=m_cache_set;
        _lCache_Size=m_cache_set<<1;
        _sbuf_InUse=_lbuf_InUse=0;
        _sbuf=(short*)malloc(_sCache_Size);
        _lbuf=(long*)malloc(_lCache_Size);
    }

    ~IndexZip(void)
    ...{
        if (_lbuf) free(_lbuf);
        if (_sbuf) free(_sbuf);
    }

    long _Clear(void)
    ...{
        if (_lbuf) free(_lbuf);
        if (_sbuf) free(_sbuf);
        _sCache_Size=_intSize;
        _lCache_Size=_intSize<<1;
        _sbuf_InUse=_lbuf_InUse=0;
        _sbuf=(short*)malloc(_sCache_Size);
        _lbuf=(long*)malloc(_lCache_Size);
    }

    long _IntCheck(void)
    ...{
        if ((!_lbuf)||(!_sbuf)) return _Error_Malloc;
        else return _Error_NoError;
    }

    long* _GetLongBuf(unsigned long &m_buf_size)
    ...{
        m_buf_size=_lbuf_InUse;
        return _lbuf;
    }

    short* _GetShortBuf(unsigned long  &m_buf_size)
    ...{
        m_buf_size=_sbuf_InUse;
        return _sbuf;
    }

    long _SetLongBuf(long *src_data,unsigned long m_buf_size)
    ...{
        if (m_buf_size>_lCache_Size)
        ...{
            long *tmpPtr=(long *)realloc(_lbuf,m_buf_size);
            if (!tmpPtr) return _Error_Malloc;
            else ...{_lbuf=tmpPtr;_lCache_Size=m_buf_size;}
        }
        memcpy(_lbuf,src_data,m_buf_size);
        _lbuf_InUse=_lCache_Size;
        return _Error_NoError;
    }

    long _SetLongBuf(FILE *_in_f ,unsigned long _in_s,unsigned long _in_L)
    ...{
        if (_lCache_Size<_in_L)
        ...{
            long *tmpPtr=(long *)realloc(_lbuf,_in_L);
            if (!tmpPtr) return _Error_Malloc;
            else ...{_lbuf=tmpPtr;_lCache_Size=_in_L;}
        }
        unsigned long n=_in_L>>2;
        unsigned long i=0;
        do ...{ fseek(_in_f,_in_s,SEEK_SET); i++;}
        while (n!=fread(_lbuf,4,n,_in_f) && (i<=3));
        if (i>3) ...{return _Error_FileRead;}
        _lbuf_InUse=_in_L;
        return _Error_NoError;
    }

    long _SetShortBuf(long *src_data,unsigned long m_buf_size)
    ...{
        if (m_buf_size>_sCache_Size)
        ...{
            short *tmpPtr=(short *)realloc(_sbuf,m_buf_size);
            if (!tmpPtr) return _Error_Malloc;
            else ...{_sbuf=tmpPtr;_sCache_Size=m_buf_size;}
        }
        memcpy(_sbuf,src_data,m_buf_size);
        _sbuf_InUse=m_buf_size;
        return _Error_NoError;
    }

    long _SetShortBuf(FILE *_in_f ,unsigned long _in_s,unsigned long _in_L)
    ...{
        if (_sCache_Size<_in_L)
        ...{
            short *tmpPtr=(short *)realloc(_sbuf,_in_L);
            if (!tmpPtr) return _Error_Malloc;
            else ...{_sbuf=tmpPtr;_sCache_Size=_in_L;}
        }
        unsigned long n=_in_L>>1;
        unsigned long i=0;
        do ...{ fseek(_in_f,_in_s,SEEK_SET); i++;}
        while (n!=fread(_sbuf,2,n,_in_f) && (i<=3));
        if (i>3) ...{return _Error_FileRead;}
        _sbuf_InUse=_in_L;
        return _Error_NoError;
    }

    long _WriteLongBuf(FILE *_out_f,unsigned long _out_s)
    ...{
        fseek(_out_f,_out_s,SEEK_SET);
        fwrite(_lbuf,4,_lbuf_InUse>>2,_out_f);
        return _Error_NoError;
    }

    long _WriteShortBuf(FILE *_out_f,unsigned long _out_s)
    ...{
        fseek(_out_f,_out_s,SEEK_SET);
        fwrite(_sbuf,2,_sbuf_InUse>>1,_out_f);
        return _Error_NoError;
    }
    long _Encodebuf(void)
    ...{
        if (_sCache_Size<_lbuf_InUse)
        ...{
            short *tmpPtr=(short *)realloc(_sbuf,_lbuf_InUse);
            if (!tmpPtr) ...{_sbuf_InUse=0;return _Error_Malloc;}
            else ...{_sbuf=tmpPtr;_sCache_Size=_lbuf_InUse;}
        }

        _asm ...{
            push esi //;//lPtr
            push edi //;//sPtr

            mov eax,dword ptr [this]
            mov edi,dword ptr [eax+4]

            mov ecx,dword ptr [eax]
            add ecx,dword ptr [eax+0ch]

            mov esi,dword ptr [eax]
iForLptrHead:
            cmp esi,ecx
            jae iForLptrEnd

            mov ax,word ptr [esi]
            add esi,4
            mov word ptr [edi],ax
            add edi,2

            mov eax,dword ptr [esi]
            add esi,4
            mov edx,eax

iDoLoopHead:
            mov ebx,eax
            sar eax,0fh

            test eax,eax
            je iifjmpHead

            or eax,8000h;
            mov word ptr [edi],ax
            add edi,2

            and ebx,7fffh
            mov word ptr [edi],bx
            add edi,2

            jmp iifjmpEnd
iifjmpHead:
            mov word ptr [edi],bx
            add edi,2
iifjmpEnd:

            mov eax,dword ptr [esi]
            add esi,4
            mov ebx,edx
            mov edx,eax
            sub eax,ebx
            test eax,eax
            jns iDoLoopHead
iDoLoopEnd:
            mov word ptr [edi],0
            add edi,2
            jmp iForLptrHead
iForLptrEnd:
            mov ecx,edi
            pop edi //;//sPtr
            pop esi //;//lPtr
            mov eax,dword ptr [this]
            sub ecx,dword ptr [eax+4] 
            mov dword ptr [eax+10h],ecx
        }
        return _Error_NoError;
    }

    long _Encodebuf(FILE *_in_f ,unsigned long _in_s,unsigned long _in_L)
    ...{
        long i=_SetLongBuf(_in_f,_in_s,_in_L);
        if (i) return i;
        return _Encodebuf();
    }

    long _Encodebuf(FILE *_out_f,unsigned long _out_s)
    ...{
        long i=_Encodebuf();
        if (i) return i;
        return _WriteShortBuf(_out_f,_out_s);
    }

    long _Encodebuf(FILE *_in_f ,unsigned long _in_s,unsigned long _in_L,FILE *_out_f,unsigned long _out_s)
    ...{
        long i=_SetLongBuf(_in_f,_in_s,_in_L);
        if (i) return i;
        i=_Encodebuf();
        if (i) return i;
        return _WriteShortBuf(_out_f,_out_s);
    }

    long _Decodebuf(void)
    ...{
        unsigned long n=_sbuf_InUse<<1;
        if (_lCache_Size<n)
        ...{
            long *tmpPtr=(long *)realloc(_lbuf,n);
            if (!tmpPtr) return _Error_Malloc;
            else ...{_lbuf=tmpPtr;_lCache_Size=n;}
        }

        n=_sbuf_InUse>>1;
        long j=0;
        for (unsigned long i=0;i<n;)
        ...{
            _lbuf[j++]=(long)_sbuf[i++];        //处理文件号
            short tmpS=_sbuf[i++];                //处理偏移
            long oldoffset=0;
            do
            ...{
                if (tmpS&0x8000) _lbuf[j++]=oldoffset=(((long)tmpS&0x7FFF)<<15)+_sbuf[i++]+oldoffset;
                else _lbuf[j++]=oldoffset=(long)tmpS+oldoffset;
                tmpS=_sbuf[i++];
            } while (tmpS);
            _lbuf[j++]=0;
        }
        _lbuf_InUse=j<<2;
        return _Error_NoError;
    }

    long _Decodebuf(FILE *_in_f ,unsigned long _in_s,unsigned long _in_L)
    ...{
        long i=_SetShortBuf(_in_f,_in_s,_in_L);
        if (i) return i;
        return _Encodebuf();
    }

    long _Decodebuf(FILE *_out_f,unsigned long _out_s)
    ...{
        long i= _Decodebuf();
        if (i) return i;
        return _WriteLongBuf(_out_f,_out_s);
    }

    long _Decodebuf(FILE *_in_f ,unsigned long _in_s,unsigned long _in_L,FILE *_out_f,unsigned long _out_s)
    ...{
        long i=_SetShortBuf(_in_f,_in_s,_in_L);
        if (i) return i;
        i= _Decodebuf();
        if (i) return i;
        return _WriteLongBuf(_out_f,_out_s);
    }
} ;