MikelSV Core / Unlimited Matrix

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// NEW UNLIMITED MATRIX///////////////////////////////////////////////////////////////////////////////////////////////////////////
class LString; // your class Index

// Defines
//#define DLString_sz sizeof(DData) // General data size



#ifndef LString_minmem
#define LString_minmem  1024
#endif
#define LString_minel   16

//class LString_um{ char*n; unsigned int sz; char data[0]; };

class LString{// Unlimited Matrix
protected:
unsigned int allsize, usedsize, bufsize, blocks;
UMX_data *data, *edata, *cdata; unsigned int cblockfn, esz;
const char nullel;
bool isdel;
public:
LString(unsigned int buf=LString_minmem) : nullel(){ Init(); bufsize=buf; }
~LString(){Clear();}

void operator=(const char *s){ Clear(); add(s, (unsigned int)strlen(s)); }
void operator=(const MString& s){ Clear(); add(s, s); }
void operator=(const VString& s){ Clear(); add(s, s); }
//void operator+=(const MString &s){ add(s, s); }
void operator+=(const char *s){ add(s, strlen(s)); }
void operator+=(const char s){ add((char*)&s, 1); }
void operator+=(const VString &s){ add(s, s); }
void resize(unsigned int s){ usedsize=s; }


void String(MString &ret){
    ret.Reserv(usedsize*sizeof(char));
    unsigned int pos=0, sz;
    UMX_data *dt=data;

    while(dt){
        if(dt->sz+pos<ret.size()) sz=dt->sz; else { sz=ret.size()-pos; }
        memcpy(ret.pos(pos), dt->data, sz*sizeof(char)); pos+=sz;
        dt=dt->n;
    }
}


const LString& operator+=(LString& lst){
unsigned int dsz, asz=lst.usedsize; UMX_data*dt=lst.data;

if(lst.data) while(dt){
    dsz=dt->sz; if(dsz<asz){ asz-=dsz; }else{ dsz=asz; }
    add((char*)&dt->data, dsz);
    dt=dt->n;
    }
    return *this;
}

int Send(SOCKET sock){
int ret=1, sz, rets=0; cdata=data; cblockfn=0;
    while(cdata){
        if(usedsize-cblockfn>cdata->sz) sz=cdata->sz; else sz=usedsize-cblockfn;
        ret=send(sock, (char*)(&cdata->data), sz, 0); if(ret>0) rets+=ret; else return 0;
        cblockfn+=cdata->sz; cdata=cdata->n;
    }
return rets;
}

inline const unsigned int addnf(const char *s, const unsigned int sz=1){ if(allsize-usedsize<sz) usedsize=allsize; return add(s, sz); } // no frag
inline char* addnfv(const unsigned int sz){ return &el(addnf(0, sz)); } // no frag, virtual

// NOTE!! Modify new(e)char  => *e=0;


void Init(){ memset(this, 0, sizeof(LString)); }

void NewBlockSz(unsigned int buf){ if(buf>=sizeof(char)) bufsize=buf; }
void NewBlockESz(unsigned int buf){ if(buf>0) bufsize=buf*sizeof(char); }
unsigned int size()const {return usedsize;}

//const LString& operator+=(char *s){ return add(s, strlen(s)/sizeof(char));}
//const LString& operator+=(MString &s){ return add(s, s);}

const char& operator[](const unsigned int e){ return getelement(e); }
const char& operator[](const int e){ return getelement(e); }

char& el(const unsigned int e){ return getelement(e); }

char& getelement(unsigned int e){
if(!cdata || e<cblockfn){ cdata=data; cblockfn=0; }
    while(cdata){
        if(e<cblockfn+cdata->sz) return *((char*)(&cdata->data)+(e-cblockfn));
        cblockfn+=cdata->sz; cdata=cdata->n;
    }
return (char&)nullel;
}

void *GetBuffer(int sz){
    void *d = malloc(sz);
    memset(d, 0, sz);
    return d;
}

void DelBuffer(void *p){
    free(p);
}

inline const unsigned int add(const char &s){ return add(&s, sizeof(char)); }
//inline char& inserta(){return (char&)*insert();}

inline const unsigned int add(const char *s, const unsigned int sz=1){ if(!sz) return -1;
    if(!bufsize) bufsize=LString_minmem; unsigned int ret=usedsize;
    unsigned int frs=allsize-usedsize, ws;
    if(frs && edata){ ws=sz; if(ws>frs) ws=frs;
        if(s){ memcpy((char*)&edata->data+esz-frs, s, ws*sizeof(char)); }
        usedsize+=ws;
        if(ws==sz) return ret;
    }
    ws=bufsize/sizeof(char); if(ws<1) ws=1; if(sz>ws) ws=sz;
    UMX_data *ndata=(UMX_data*)GetBuffer(ws*sizeof(char)+UMSZ+(isdel ? (sizeof(mbool)+ws/8 + (ws%8>0 ? 1 : 0)) : 0)); blocks++;
    if(isdel) {*((mbool*)((char*)ndata)+ws*sizeof(char)+UMSZ)=(bool*)(((char*)ndata)+ws*sizeof(char)+UMSZ+sizeof(mbool));}
    allsize+=ws; usedsize+=sz-frs; //ws=bufsize; if(sz-frs>ws) ws=sz-frs;
    ndata->sz=ws; esz=ws; //*(unsigned int*)((char*)ndata)=ws; esz=ws;// ndata+=UMSZ;
    if(edata){ edata->n=ndata; }
    edata=ndata; if(!data) data=edata;
    if(s) memcpy(edata->data, s+frs, (sz-frs)*sizeof(char));
return ret;
}

inline char& inserta(){ return (char&)getelement(insert()); }
inline char* vinsert(){ return (char*)&getelement(insert()); }
inline char& repaira(){ return (char&)getelement(repair()); }
inline char* vrepair(){ return (char*)&getelement(repair()); }

inline unsigned int insert(){ char tm[sizeof(char)]; memset(&tm, 0, sizeof(char)); unsigned int ed=add((char*)&tm, 1); char*e=&getelement(ed); memset(e, 0, sizeof(*e)); return ed; }

bool del(unsigned int e){
if(!cdata || e<cblockfn){ cdata=data; cblockfn=0; }
    while(cdata){
        if(e<cblockfn+cdata->sz){
                #ifdef DLString_constructor
            ((char*)cdata.data+(e-cblockfn))->~char();
                #endif
             if(isdel) ((mbool*)(cdata+cdata->sz))->set(e-cblockfn, 0);
             return 1;
        }
        cdata=cdata->n; cblockfn+=cdata->sz;
    }
return 0;
}

unsigned int repair(){ if(!isdel) return insert();
int s; mbool *mb; if(!cdata || 0<cblockfn){ cdata=data; cblockfn=0; }
    while(cdata){
        //s=*(unsigned int*)((char*)cdata-UMSZ);
        int i=0; mb=(mbool*)(cdata->data+s);

        for(i; i<s; i++){ if(i%8==0 && mb->isbyte(i/8)==255){ i+=8; continue; }
        if(!mb->get(i)){// if(cblockfn+i<usedsize) return insert();
         mb->set(i, 1);
#ifdef DLString_constructor
        new((char*)cdata->data+i)char;
#endif
        return cblockfn+i;
    }}
        cdata=cdata->n; cblockfn+=s;
    }
 return insert();
}

bool is(unsigned int e){ if(!isdel) return 1;
    if(!cdata || e<cblockfn){ cdata=data; cblockfn=0; }
    while(cdata){
        if(e<cblockfn+cdata->sz){
             return ((mbool*)((char*)cdata->data+cdata->sz))->get(e-cblockfn);
        }
        cdata=cdata->n; cblockfn+=cdata->sz;
    }
return 0;
}

unsigned int getpos(const char *pos){
    cdata=data; cblockfn=0;
    while(cdata){
        if((char*)&cdata->data<=pos && pos<(char*)&cdata->data+cdata->sz){
             return cblockfn+(pos-(char*)(&cdata->data));
        }
        cdata=cdata->n; cblockfn+=cdata->sz;
    }
return -1;
}

// SP
unsigned int GetFreeBuffer(char**data){
    if(allsize==usedsize){ add((char*)&nullel, 1); usedsize--; }
    unsigned int fs=allsize-usedsize;
    *data=(char*)&edata->data+esz-fs;
    return fs;
}

void SetFreeBuffer(unsigned int add){ usedsize+=esz-add; }

//const LString& operator=(char *s){Clear(); return add(s, strlen(s));}
//const LString& operator=(MString s){Clear(); return add(s, s);}

operator MString(){
    MString ret; ret.Reserv(usedsize*sizeof(char));
    unsigned int pos=0, sz;
    UMX_data*dt=data;

    if(data) while(dt){
        if(dt->sz+pos<ret.size()) sz=dt->sz;
        else{ sz=ret.size()-pos; }
        memcpy(ret.pos(pos), &dt->data, sz*sizeof(char)); pos+=sz;
        dt=dt->n;
    }
    return ret;
}

char* pos(){ if(!data) return 0; return (char*)data->data; }
operator char*(){ if(!data) return 0; return (char*)data->data; }
char* nomov(){ return oneline(); }

char* oneline(bool delfree=1){
    if(!data) return 0; if(data==edata) return (char*)data->data;
    if(delfree) esz=usedsize; else esz=allsize;
    UMX_data *ndata=(UMX_data*)GetBuffer(esz*sizeof(char)+UMSZ);
    //*(unsigned int*)((char*)ndata)=esz; ndata+=UMSZ;
    ndata->sz=esz;
    unsigned int pos=0, sz;

    UMX_data *dt=data, *dd;
    while(dt){
        if(dt->sz+pos<usedsize) sz=dt->sz; else{ sz=usedsize-pos; }
        memcpy(ndata->data+pos*sizeof(char), dt->data, sz*sizeof(char)); pos+=sz;
//memcpy(&dd, (char*)(dt-4), 4);
//*(long*)(char*)&dt=*(long*)((char*)dt-UMCSZ);
        dd=dt; dt=dt->n; DelBuffer(dd);
    }
    data=ndata; edata=data; cdata=0; blocks=1; allsize=usedsize;
    return (char*)data->data;
}

void Clear(){ if(!data) return ;
    UMX_data *dt=data, *dd;
    unsigned int pos=0, dsz, msz;

    while(dt){
        dsz=dt->sz; msz=dsz; if(dsz+pos>usedsize) msz=usedsize-pos;
#ifdef DLString_destructor
        for(unsigned int i=0; i<msz; i++){
            ((char*)dt->data+i)->~char();
        }
#endif
        dd=dt; dt=dt->n;
        DelBuffer(dd);
    }
    data=0; edata=0; cdata=0; allsize=0; usedsize=0;
}

// Add Func
    void i_want_mod_usedsize(int pos){ usedsize=pos; }

};