zStr Class Reference

#include <zstr.h>

Inheritance diagram for zStr:

Collaboration diagram for zStr:

Public Member Functions
signed char	findKeyIndex (const char *ikey, long *idxoff, long away=0) const
void	getText (long index, char **idxbuf, char **buf) const
void	linkEntry (const char *destkey, const char *srckey)
virtual void	rawZFilter (SWBuf &buf, char direction=0) const
void	setText (const char *ikey, const char *buf, long len=-1)
	zStr (const char *ipath, int fileMode=-1, long blockCount=100, SWCompress *icomp=0, bool caseSensitive=false)
virtual	~zStr ()

Static Public Member Functions
static signed char	createModule (const char *path)

Protected Member Functions
void	flushCache () const
void	getCompressedText (long block, long entry, char **buf) const
void	getKeyFromDatOffset (long ioffset, char **buf) const
void	getKeyFromIdxOffset (long ioffset, char **buf) const

Protected Attributes
FileDesc *	datfd
FileDesc *	idxfd
FileDesc *	zdtfd
FileDesc *	zdxfd

Static Protected Attributes
static const int	IDXENTRYSIZE = 8
static const int	ZDXENTRYSIZE = 8

Private Attributes
long	blockCount
EntriesBlock *	cacheBlock
long	cacheBlockIndex
bool	cacheDirty
bool	caseSensitive
SWCompress *	compressor
long	lastoff
char *	path

Static Private Attributes
static int	instance = 0

Detailed Description

Definition at line 36 of file zstr.h.

Constructor & Destructor Documentation

zStr::zStr	(	const char *	ipath,
		int	fileMode = -1,
		long	blockCount = 100,
		SWCompress *	icomp = 0,
		bool	caseSensitive = false
	)

Definition at line 59 of file zstr.cpp.

                                                                                                  : caseSensitive(caseSensitive)
{
    SWBuf buf;

    lastoff = -1;
    path = 0;
    stdstr(&path, ipath);

    compressor = (icomp) ? icomp : new SWCompress();
    this->blockCount = blockCount;

    if (fileMode == -1) { // try read/write if possible
        fileMode = FileMgr::RDWR;
    }
        
    buf.setFormatted("%s.idx", path);
    idxfd = FileMgr::getSystemFileMgr()->open(buf, fileMode, true);

    buf.setFormatted("%s.dat", path);
    datfd = FileMgr::getSystemFileMgr()->open(buf, fileMode, true);

    buf.setFormatted("%s.zdx", path);
    zdxfd = FileMgr::getSystemFileMgr()->open(buf, fileMode, true);

    buf.setFormatted("%s.zdt", path);
    zdtfd = FileMgr::getSystemFileMgr()->open(buf, fileMode, true);

    if (!zdtfd || zdtfd->getFd() < 0) {
// couldn't find datafile but this might be fine if we're
// merely instantiating a remote InstallMgr SWMgr
SWLOGD("Couldn't open file: %s. errno: %d", buf.c_str(), errno);
    }

    cacheBlock = 0;
    cacheBlockIndex = -1;
    cacheDirty = false;

    instance++;
}

zStr::~zStr ( )

virtual

Definition at line 104 of file zstr.cpp.

            {

    flushCache();

    if (path)
        delete [] path;

    --instance;

    FileMgr::getSystemFileMgr()->close(idxfd);
    FileMgr::getSystemFileMgr()->close(datfd);
    FileMgr::getSystemFileMgr()->close(zdxfd);
    FileMgr::getSystemFileMgr()->close(zdtfd);


    if (compressor)
        delete compressor;

}

Member Function Documentation

signed char zStr::createModule ( const char *  path )

static

Definition at line 663 of file zstr.cpp.

                                                {
    char *path = 0;
    char *buf = new char [ strlen (ipath) + 20 ];
    FileDesc *fd, *fd2;

    stdstr(&path, ipath);

    if ((path[strlen(path)-1] == '/') || (path[strlen(path)-1] == '\\'))
        path[strlen(path)-1] = 0;

    sprintf(buf, "%s.dat", path);
    FileMgr::removeFile(buf);
    fd = FileMgr::getSystemFileMgr()->open(buf, FileMgr::CREAT|FileMgr::WRONLY, FileMgr::IREAD|FileMgr::IWRITE);
    fd->getFd();
    FileMgr::getSystemFileMgr()->close(fd);

    sprintf(buf, "%s.idx", path);
    FileMgr::removeFile(buf);
    fd2 = FileMgr::getSystemFileMgr()->open(buf, FileMgr::CREAT|FileMgr::WRONLY, FileMgr::IREAD|FileMgr::IWRITE);
    fd2->getFd();
    FileMgr::getSystemFileMgr()->close(fd2);

    sprintf(buf, "%s.zdt", path);
    FileMgr::removeFile(buf);
    fd2 = FileMgr::getSystemFileMgr()->open(buf, FileMgr::CREAT|FileMgr::WRONLY, FileMgr::IREAD|FileMgr::IWRITE);
    fd2->getFd();
    FileMgr::getSystemFileMgr()->close(fd2);

    sprintf(buf, "%s.zdx", path);
    FileMgr::removeFile(buf);
    fd2 = FileMgr::getSystemFileMgr()->open(buf, FileMgr::CREAT|FileMgr::WRONLY, FileMgr::IREAD|FileMgr::IWRITE);
    fd2->getFd();
    FileMgr::getSystemFileMgr()->close(fd2);

    delete [] path;
    
    return 0;
}

signed char zStr::findKeyIndex	(	const char *	ikey,
		long *	idxoff,
		long	away = 0
	)		const

Definition at line 193 of file zstr.cpp.

{
    char *maxbuf = 0, *trybuf = 0, *key = 0, quitflag = 0;
    signed char retval = 0;
    SW_s32 headoff, tailoff, tryoff = 0, maxoff = 0;
    SW_u32 start, size;
    int diff = 0;
    bool awayFromSubstrCheck = false;

    if (idxfd->getFd() >= 0) {
        tailoff = maxoff = (SW_s32)idxfd->seek(0, SEEK_END) - IDXENTRYSIZE;
        if (*ikey) {
            headoff = 0;
            stdstr(&key, ikey, 3);
            if (!caseSensitive) toupperstr_utf8(key, (unsigned int)(strlen(key)*3));

            int keylen = (int)strlen(key);
            bool substr = false;

            getKeyFromIdxOffset(maxoff, &maxbuf);

            while (headoff < tailoff) {
                tryoff = ((SW_s32)lastoff == -1) ? headoff + (((((tailoff / IDXENTRYSIZE) - (headoff / IDXENTRYSIZE))) / 2) * IDXENTRYSIZE) : (SW_s32)lastoff;
                lastoff = -1;

                getKeyFromIdxOffset(tryoff, &trybuf);

                if (!*trybuf && tryoff) {       // In case of extra entry at end of idx (not first entry)
                    tryoff += (tryoff > (maxoff / 2))?-IDXENTRYSIZE:IDXENTRYSIZE;
                    retval = -1;
                    break;
                }

                diff = strcmp(key, trybuf);

                if (!diff)
                    break;

                if (!strncmp(trybuf, key, keylen)) substr = true;

                if (diff < 0)
                    tailoff = (tryoff == headoff) ? headoff : tryoff;
                else headoff = tryoff;

                if (tailoff == headoff + IDXENTRYSIZE) {
                    if (quitflag++)
                        headoff = tailoff;
                }
            }

            // didn't find exact match
            if (headoff >= tailoff) {
                tryoff = headoff;
                if (!substr && ((tryoff != maxoff)||(strncmp(key, maxbuf, keylen)<0))) {
                    awayFromSubstrCheck = true;
                    away--; // if our entry doesn't startwith our key, prefer the previous entry over the next
                }
            }
            if (trybuf)
                free(trybuf);
            delete [] key;
                        if (maxbuf)
                            free(maxbuf);
        }
        else    { tryoff = 0; }

        idxfd->seek(tryoff, SEEK_SET);

        start = size = 0;
        retval = (idxfd->read(&start, 4) == 4) ? retval : -1;
        retval = (idxfd->read(&size, 4) == 4) ? retval : -1;
        start = swordtoarch32(start);
        size  = swordtoarch32(size);

        if (idxoff)
            *idxoff = tryoff;

        while (away) {
            SW_u32 laststart = start;
            SW_u32 lastsize = size;
            SW_s32 lasttry = tryoff;
            tryoff += (away > 0) ? IDXENTRYSIZE : -IDXENTRYSIZE;

            bool bad = false;
            if (((long)(tryoff + (away*IDXENTRYSIZE)) < -IDXENTRYSIZE) || (tryoff + (away*IDXENTRYSIZE) > (maxoff+IDXENTRYSIZE)))
                bad = true;
            else    if (idxfd->seek(tryoff, SEEK_SET) < 0)
                bad = true;
            if (bad) {
                if(!awayFromSubstrCheck)
                    retval = -1;
                start = laststart;
                size = lastsize;
                tryoff = lasttry;
                if (idxoff)
                    *idxoff = tryoff;
                break;
            }
            idxfd->read(&start, 4);
            idxfd->read(&size, 4);
            start = swordtoarch32(start);
            size  = swordtoarch32(size);

            if (idxoff)
                *idxoff = tryoff;


            if (((laststart != start) || (lastsize != size)) && size)
                away += (away < 0) ? 1 : -1;
        }
    
        lastoff = tryoff;
    }
    else {
        if (idxoff)
            *idxoff = 0;
        retval = -1;
    }
    return retval;
}

void zStr::flushCache ( ) const

protected

Definition at line 590 of file zstr.cpp.

                            {

    static const char nl[] = {13, 10};

    if (cacheBlock) {
        if (cacheDirty) {
            SW_u32 start = 0;
            unsigned long size = 0;
            SW_u32 outstart = 0, outsize = 0;

            const char *rawBuf = cacheBlock->getRawData(&size);
            compressor->setUncompressedBuf(rawBuf, &size);
            compressor->getCompressedBuf(&size);

            SWBuf buf;
            buf.setSize(size + 5);
            memcpy(buf.getRawData(), compressor->getCompressedBuf(&size), size); // 1 = encipher
            buf.setSize(size);
            rawZFilter(buf, 1); // 1 = encipher

            long zdxSize = zdxfd->seek(0, SEEK_END);
            unsigned long zdtSize = zdtfd->seek(0, SEEK_END);

            if ((cacheBlockIndex * ZDXENTRYSIZE) > (zdxSize - ZDXENTRYSIZE)) {  // New Block
                start = (SW_u32)zdtSize;
            }
            else {
                zdxfd->seek(cacheBlockIndex * ZDXENTRYSIZE, SEEK_SET);
                zdxfd->read(&start, 4);
                zdxfd->read(&outsize, 4);
                start = swordtoarch32(start);
                outsize = swordtoarch32(outsize);
                if (start + outsize >= zdtSize) {   // last entry, just overwrite
                    // start is already set
                }
                else    if (size < outsize) {   // middle entry, but smaller, that's fine and let's preserve bigger size
                    size = outsize;
                }
                else {  // middle and bigger-- we have serious problems, for now let's put it at the end = lots of wasted space
                    start = (SW_u32)zdtSize;
                }
            }



            outstart = archtosword32(start);
            outsize  = archtosword32((SW_u32)size);

            zdxfd->seek(cacheBlockIndex * ZDXENTRYSIZE, SEEK_SET);
            zdtfd->seek(start, SEEK_SET);
            zdtfd->write(buf, size);

            // add a new line to make data file easier to read in an editor
            zdtfd->write(&nl, 2);
            
            zdxfd->write(&outstart, 4);
            zdxfd->write(&outsize, 4);
        }
        delete cacheBlock;
        cacheBlock = 0;
    }
    cacheBlockIndex = -1;
    cacheDirty = false;
}

void zStr::getCompressedText ( long  block, long  entry, char **  buf  ) const

protected

Definition at line 392 of file zstr.cpp.

                                                                     {

    SW_u32 size = 0;

    if (cacheBlockIndex != block) {
        SW_u32 start = 0;

        zdxfd->seek(block * ZDXENTRYSIZE, SEEK_SET);
        zdxfd->read(&start, 4);
        zdxfd->read(&size, 4);
        start = swordtoarch32(start);
        size = swordtoarch32(size);

        SWBuf buf;
        buf.setSize(size + 5);
        zdtfd->seek(start, SEEK_SET);
        zdtfd->read(buf.getRawData(), size);

        flushCache();

        unsigned long len = size;
        buf.setSize(size);
        rawZFilter(buf, 0); // 0 = decipher

        compressor->setCompressedBuf(&len, buf.getRawData());
        char *rawBuf = compressor->getUncompressedBuf(&len);
        cacheBlock = new EntriesBlock(rawBuf, len);
        cacheBlockIndex = block;
    }
    size = (SW_u32)cacheBlock->getEntrySize(entry);
    *buf = (*buf) ? (char *)realloc(*buf, size*2 + 1) : (char *)malloc(size*2 + 1);
    strcpy(*buf, cacheBlock->getEntry(entry));
}

void zStr::getKeyFromDatOffset ( long  ioffset, char **  buf  ) const

protected

Definition at line 134 of file zstr.cpp.

{
    int size;
    char ch;
    if (datfd && datfd->getFd() >= 0) {
        datfd->seek(ioffset, SEEK_SET);
        for (size = 0; datfd->read(&ch, 1) == 1; size++) {
            if ((ch == '\\') || (ch == 10) || (ch == 13))
                break;
        }
        *buf = (*buf) ? (char *)realloc(*buf, size*2 + 1) : (char *)malloc(size*2 + 1);
        if (size) {
            datfd->seek(ioffset, SEEK_SET);
            datfd->read(*buf, size);
        }
        (*buf)[size] = 0;
        if (!caseSensitive) toupperstr_utf8(*buf, size*2);
    }
    else {
        *buf = (*buf) ? (char *)realloc(*buf, 1) : (char *)malloc(1);
        **buf = 0;
    }
}

void zStr::getKeyFromIdxOffset ( long  ioffset, char **  buf  ) const

protected

Definition at line 168 of file zstr.cpp.

{
    SW_u32 offset;
    
    if (idxfd && idxfd->getFd() >= 0) {
        idxfd->seek(ioffset, SEEK_SET);
        idxfd->read(&offset, 4);
        offset = swordtoarch32(offset);
        getKeyFromDatOffset(offset, buf);
    }
}

void zStr::getText	(	long	index,
		char **	idxbuf,
		char **	buf
	)		const

Definition at line 327 of file zstr.cpp.

                                                               {
    char *ch;
    char *idxbuflocal = 0;
    getKeyFromIdxOffset(offset, &idxbuflocal);
    SW_u32 start;
    SW_u32 size;

    do {
        idxfd->seek(offset, SEEK_SET);
        idxfd->read(&start, 4);
        idxfd->read(&size, 4);
        start = swordtoarch32(start);
        size = swordtoarch32(size);

        *buf = (*buf) ? (char *)realloc(*buf, size*2 + 1) : (char *)malloc(size*2 + 1);
        *idxbuf = (*idxbuf) ? (char *)realloc(*idxbuf, size*2 + 1) : (char *)malloc(size*2 + 1);
        memset(*buf, 0, size + 1);
        memset(*idxbuf, 0, size + 1);
        datfd->seek(start, SEEK_SET);
        datfd->read(*buf, (int)(size));

        for (ch = *buf; *ch; ch++) {        // skip over index string
            if (*ch == 10) {
                ch++;
                break;
            }
        }
        memmove(*buf, ch, size - (unsigned long)(ch-*buf));

        // resolve link
        if (!strncmp(*buf, "@LINK", 5)) {
            for (ch = *buf; *ch; ch++) {        // null before nl
                if (*ch == 10) {
                    *ch = 0;
                    break;
                }
            }
            findKeyIndex(*buf + 6, &offset);
        }
        else break;
    }
    while (true);   // while we're resolving links

    if (idxbuflocal) {
        SW_u32 localsize = (SW_u32)strlen(idxbuflocal);
        localsize = (localsize < (size - 1)) ? localsize : (size - 1);
        strncpy(*idxbuf, idxbuflocal, localsize);
        (*idxbuf)[localsize] = 0;
        free(idxbuflocal);
    }
    SW_u32 block = 0;
    SW_u32 entry = 0;
    memmove(&block, *buf, sizeof(SW_u32));
    memmove(&entry, *buf + sizeof(SW_u32), sizeof(SW_u32));
    block = swordtoarch32(block);
    entry = swordtoarch32(entry);
    getCompressedText(block, entry, buf);
}

void zStr::linkEntry	(	const char *	destkey,
		const char *	srckey
	)

Definition at line 582 of file zstr.cpp.

                                                            {
    char *text = new char [ strlen(destkey) + 7 ];
    sprintf(text, "@LINK %s", destkey);
    setText(srckey, text);
    delete [] text;
}

virtual void zStr::rawZFilter ( SWBuf &  buf, char  direction = 0  ) const

inlinevirtual

Reimplemented in zLD.

Definition at line 69 of file zstr.h.

{ (void) buf; (void) direction; }

void zStr::setText	(	const char *	ikey,
		const char *	buf,
		long	len = -1
	)

Definition at line 435 of file zstr.cpp.

                                                              {

    static const char nl[] = {13, 10};

    SW_u32 start, outstart;
    SW_u32 size, outsize;
    SW_s32 endoff;
    long idxoff = 0;
    SW_s32 shiftSize;
    char *tmpbuf = 0;
    char *key = 0;
    char *dbKey = 0;
    char *idxBytes = 0;
    char *outbuf = 0;
    char *ch = 0;

    len = (len < 0) ? strlen(buf) : len;
    stdstr(&key, ikey, 3);
    if (!caseSensitive) toupperstr_utf8(key, (unsigned int)(strlen(key)*3));

    char notFound = findKeyIndex(ikey, &idxoff, 0);
    if (!notFound) {
        getKeyFromIdxOffset(idxoff, &dbKey);
        int diff = strcmp(key, dbKey);
        if (diff < 0) {
        }
        else if (diff > 0) {
            idxoff += IDXENTRYSIZE;
        }
        else if ((!diff) && (len > 0 /*we're not deleting*/)) { // got absolute entry
            do {
                idxfd->seek(idxoff, SEEK_SET);
                idxfd->read(&start, 4);
                idxfd->read(&size, 4);
                start = swordtoarch32(start);
                size = swordtoarch32(size);

                tmpbuf = new char [ size + 2 ];
                memset(tmpbuf, 0, size + 2);
                datfd->seek(start, SEEK_SET);
                datfd->read(tmpbuf, size);

                for (ch = tmpbuf; *ch; ch++) {      // skip over index string
                    if (*ch == 10) {
                        ch++;
                        break;
                    }
                }
                memmove(tmpbuf, ch, size - (unsigned long)(ch-tmpbuf));

                // resolve link
                if (!strncmp(tmpbuf, "@LINK", 5) && (len)) {
                    for (ch = tmpbuf; *ch; ch++) {      // null before nl
                        if (*ch == 10) {
                            *ch = 0;
                            break;
                        }
                    }
                    findKeyIndex(tmpbuf + IDXENTRYSIZE, &idxoff);
                    delete [] tmpbuf;
                }
                else break;
            }
            while (true);   // while we're resolving links
        }
    }

    endoff = (SW_s32)idxfd->seek(0, SEEK_END);

    shiftSize = endoff - (SW_s32)idxoff;

    if (shiftSize > 0) {
            idxBytes = new char [ shiftSize ];
        idxfd->seek(idxoff, SEEK_SET);
        idxfd->read(idxBytes, shiftSize);
    }

    outbuf = new char [ len + strlen(key) + 5 ];
    sprintf(outbuf, "%s%c%c", key, 13, 10);
    size = (SW_u32)strlen(outbuf);
    if (len > 0) {  // NOT a link
        if (!cacheBlock) {
            flushCache();
            cacheBlock = new EntriesBlock();
            cacheBlockIndex = (zdxfd->seek(0, SEEK_END) / ZDXENTRYSIZE);
        }
        else if (cacheBlock->getCount() >= blockCount) {
            flushCache();
            cacheBlock = new EntriesBlock();
            cacheBlockIndex = (zdxfd->seek(0, SEEK_END) / ZDXENTRYSIZE);
        }
        SW_u32 entry = cacheBlock->addEntry(buf);
        cacheDirty = true;
        outstart = (SW_u32)archtosword32(cacheBlockIndex);
        outsize = archtosword32(entry);
        memcpy (outbuf + size, &outstart, sizeof(SW_u32));
        memcpy (outbuf + size + sizeof(SW_u32), &outsize, sizeof(SW_u32));
        size += (sizeof(SW_u32) * 2);
    }
    else {  // link
        memcpy(outbuf + size, buf, len);
        size += len;
    }

    start = (SW_u32)datfd->seek(0, SEEK_END);

    outstart = archtosword32(start);
    outsize  = archtosword32(size);

    idxfd->seek(idxoff, SEEK_SET);
    if (len > 0) {
        datfd->seek(start, SEEK_SET);
        datfd->write(outbuf, size);

        // add a new line to make data file easier to read in an editor
        datfd->write(&nl, 2);
        
        idxfd->write(&outstart, 4);
        idxfd->write(&outsize, 4);
        if (idxBytes) {
            idxfd->write(idxBytes, shiftSize);
        }
    }
    else {  // delete entry
        if (idxBytes) {
            idxfd->write(idxBytes+IDXENTRYSIZE, shiftSize-IDXENTRYSIZE);
            idxfd->seek(-1, SEEK_CUR);  // last valid byte
            FileMgr::getSystemFileMgr()->trunc(idxfd);  // truncate index
        }
    }

    if (idxBytes)
        delete [] idxBytes;
    delete [] key;
    delete [] outbuf;
    free(dbKey);
}

Member Data Documentation

long zStr::blockCount

private

Definition at line 46 of file zstr.h.

EntriesBlock* zStr::cacheBlock

mutableprivate

Definition at line 40 of file zstr.h.

long zStr::cacheBlockIndex

mutableprivate

Definition at line 41 of file zstr.h.

bool zStr::cacheDirty

mutableprivate

Definition at line 42 of file zstr.h.

bool zStr::caseSensitive

private

Definition at line 44 of file zstr.h.

SWCompress* zStr::compressor

private

Definition at line 47 of file zstr.h.

FileDesc* zStr::datfd

protected

Definition at line 51 of file zstr.h.

const int zStr::IDXENTRYSIZE = 8

staticprotected

Definition at line 54 of file zstr.h.

FileDesc* zStr::idxfd

protected

Definition at line 50 of file zstr.h.

SWORD_NAMESPACE_START int zStr::instance = 0

staticprivate

Definition at line 39 of file zstr.h.

long zStr::lastoff

mutableprivate

Definition at line 45 of file zstr.h.

char* zStr::path

private

Definition at line 43 of file zstr.h.

FileDesc* zStr::zdtfd

protected

Definition at line 53 of file zstr.h.

const int zStr::ZDXENTRYSIZE = 8

staticprotected

Definition at line 55 of file zstr.h.

FileDesc* zStr::zdxfd

protected

Definition at line 52 of file zstr.h.

---

The documentation for this class was generated from the following files:

• include/zstr.h
• src/modules/common/zstr.cpp