zVerse Class Reference

#include <zverse.h>

Inheritance diagram for zVerse:

Collaboration diagram for zVerse:

Public Member Functions
void	findOffset (char testmt, long idxoff, long *start, unsigned short *size, unsigned long *buffnum) const
virtual void	rawZFilter (SWBuf &buf, char direction=0) const
void	zReadText (char testmt, long start, unsigned short size, unsigned long buffnum, SWBuf &buf) const
	zVerse (const char *ipath, int fileMode=-1, int blockType=CHAPTERBLOCKS, SWCompress *icomp=0)
virtual	~zVerse ()

Static Public Member Functions
static char	createModule (const char *path, int blockBound, const char *v11n="KJV")

Static Public Attributes
static const char	uniqueIndexID [] = {'X', 'r', 'v', 'c', 'b'}

Protected Member Functions
void	doLinkEntry (char testmt, long destidxoff, long srcidxoff)
void	doSetText (char testmt, long idxoff, const char *buf, long len=0)
void	flushCache () const

Protected Attributes
char *	cacheBuf
long	cacheBufIdx
unsigned int	cacheBufSize
char	cacheTestament
FileDesc *	compfp [2]
bool	dirtyCache
FileDesc *	idxfp [2]
char *	path
FileDesc *	textfp [2]

Static Protected Attributes
static int	instance = 0

Private Attributes
SWCompress *	compressor

Detailed Description

Definition at line 37 of file zverse.h.

Constructor & Destructor Documentation

zVerse::zVerse	(	const char *	ipath,
		int	fileMode = -1,
		int	blockType = CHAPTERBLOCKS,
		SWCompress *	icomp = 0
	)

Definition at line 63 of file zverse.cpp.

{
    // this line, instead of just defaulting, to keep FileMgr out of header
    if (fileMode == -1) fileMode = FileMgr::RDONLY;

    SWBuf buf;

    path = 0;
    cacheBufIdx = -1;
    cacheTestament = 0;
    cacheBuf = 0;
    dirtyCache = false;
    stdstr(&path, ipath);

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

    compressor = (icomp) ? icomp : new SWCompress();

    if (fileMode == -1) { // try read/write if possible
        fileMode = FileMgr::RDWR;
    }
        
    buf.setFormatted("%s/ot.%czs", path, uniqueIndexID[blockType]);
    idxfp[0] = FileMgr::getSystemFileMgr()->open(buf, fileMode, true);

    buf.setFormatted("%s/nt.%czs", path, uniqueIndexID[blockType]);
    idxfp[1] = FileMgr::getSystemFileMgr()->open(buf, fileMode, true);

    buf.setFormatted("%s/ot.%czz", path, uniqueIndexID[blockType]);
    textfp[0] = FileMgr::getSystemFileMgr()->open(buf, fileMode, true);

    buf.setFormatted("%s/nt.%czz", path, uniqueIndexID[blockType]);
    textfp[1] = FileMgr::getSystemFileMgr()->open(buf, fileMode, true);

    buf.setFormatted("%s/ot.%czv", path, uniqueIndexID[blockType]);
    compfp[0] = FileMgr::getSystemFileMgr()->open(buf, fileMode, true);

    buf.setFormatted("%s/nt.%czv", path, uniqueIndexID[blockType]);
    compfp[1] = FileMgr::getSystemFileMgr()->open(buf, fileMode, true);
    
    instance++;
}

zVerse::~zVerse ( )

virtual

Definition at line 112 of file zverse.cpp.

{
    int loop1;

    if (cacheBuf) {
        flushCache();
        free(cacheBuf);
    }

    if (path)
        delete [] path;

    if (compressor)
        delete compressor;

    --instance;

    for (loop1 = 0; loop1 < 2; loop1++) {
        FileMgr::getSystemFileMgr()->close(idxfp[loop1]);
        FileMgr::getSystemFileMgr()->close(textfp[loop1]);
        FileMgr::getSystemFileMgr()->close(compfp[loop1]);
    }
}

Member Function Documentation

char zVerse::createModule ( const char *  path, int  blockBound, const char *  v11n = "KJV"  )

static

Definition at line 426 of file zverse.cpp.

{
    char *path = 0;
    char *buf = new char [ strlen (ipath) + 20 ];
    char retVal = 0;
    FileDesc *fd, *fd2;
    SW_s32 offset = 0;
    SW_s16 size = 0;
    VerseKey vk;

    stdstr(&path, ipath);

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

    sprintf(buf, "%s/ot.%czs", path, uniqueIndexID[blockBound]);
    FileMgr::removeFile(buf);
    fd = FileMgr::getSystemFileMgr()->open(buf, FileMgr::CREAT|FileMgr::WRONLY, FileMgr::IREAD|FileMgr::IWRITE);
    if (fd->getFd() < 1) goto erroropen1;
    FileMgr::getSystemFileMgr()->close(fd);

    sprintf(buf, "%s/nt.%czs", path, uniqueIndexID[blockBound]);
    FileMgr::removeFile(buf);
    fd = FileMgr::getSystemFileMgr()->open(buf, FileMgr::CREAT|FileMgr::WRONLY, FileMgr::IREAD|FileMgr::IWRITE);
    if (fd->getFd() < 1) goto erroropen1;
    FileMgr::getSystemFileMgr()->close(fd);

    sprintf(buf, "%s/ot.%czz", path, uniqueIndexID[blockBound]);
    FileMgr::removeFile(buf);
    fd = FileMgr::getSystemFileMgr()->open(buf, FileMgr::CREAT|FileMgr::WRONLY, FileMgr::IREAD|FileMgr::IWRITE);
    if (fd->getFd() < 1) goto erroropen1;
    FileMgr::getSystemFileMgr()->close(fd);

    sprintf(buf, "%s/nt.%czz", path, uniqueIndexID[blockBound]);
    FileMgr::removeFile(buf);
    fd = FileMgr::getSystemFileMgr()->open(buf, FileMgr::CREAT|FileMgr::WRONLY, FileMgr::IREAD|FileMgr::IWRITE);
    if (fd->getFd() < 1) goto erroropen1;
    FileMgr::getSystemFileMgr()->close(fd);

    sprintf(buf, "%s/ot.%czv", path, uniqueIndexID[blockBound]);
    FileMgr::removeFile(buf);
    fd = FileMgr::getSystemFileMgr()->open(buf, FileMgr::CREAT|FileMgr::WRONLY, FileMgr::IREAD|FileMgr::IWRITE);
    if (fd->getFd() < 1) goto erroropen1;

    sprintf(buf, "%s/nt.%czv", path, uniqueIndexID[blockBound]);
    FileMgr::removeFile(buf);
    fd2 = FileMgr::getSystemFileMgr()->open(buf, FileMgr::CREAT|FileMgr::WRONLY, FileMgr::IREAD|FileMgr::IWRITE);
    if (fd2->getFd() < 1) goto erroropen2;

    vk.setVersificationSystem(v11n);
    vk.setIntros(true);

    offset = archtosword32(offset);
    size   = archtosword16(size);

    for (vk = TOP; !vk.popError(); vk++) {
        if (vk.getTestament() < 2) {
            if (fd->write(&offset, 4) != 4) goto writefailure;  //compBufIdxOffset
            if (fd->write(&offset, 4) != 4) goto writefailure;
            if (fd->write(&size, 2) != 2) goto writefailure;
        }
        else {
            if (fd2->write(&offset, 4) != 4) goto writefailure; //compBufIdxOffset
            if (fd2->write(&offset, 4) != 4) goto writefailure;
            if (fd2->write(&size, 2) != 2) goto writefailure;
        }
    }
    fd2->write(&offset, 4); //compBufIdxOffset
    fd2->write(&offset, 4);
    fd2->write(&size, 2);

    goto cleanup;

erroropen1:
    retVal = -1;
    goto cleanup1;

erroropen2:
    retVal = -1;
    goto cleanup;

writefailure:
    retVal = -2;

cleanup:
    FileMgr::getSystemFileMgr()->close(fd2);
cleanup1:
    FileMgr::getSystemFileMgr()->close(fd);

    delete [] path;
    delete [] buf;
    
    return retVal;
}

void zVerse::doLinkEntry ( char  testmt, long  destidxoff, long  srcidxoff  )

protected

Definition at line 394 of file zverse.cpp.

                                                                     {
    SW_s32 bufidx;
    SW_s32 start;
    SW_u16 size;

    destidxoff *= 10;
    srcidxoff  *= 10;

    if (!testmt)
        testmt = ((idxfp[1]) ? 1:2);

    // get source
    compfp[testmt-1]->seek(srcidxoff, SEEK_SET);
    compfp[testmt-1]->read(&bufidx, 4);
    compfp[testmt-1]->read(&start, 4);
    compfp[testmt-1]->read(&size, 2);

    // write dest
    compfp[testmt-1]->seek(destidxoff, SEEK_SET);
    compfp[testmt-1]->write(&bufidx, 4);
    compfp[testmt-1]->write(&start, 4);
    compfp[testmt-1]->write(&size, 2);
}

void zVerse::doSetText ( char  testmt, long  idxoff, const char *  buf, long  len = 0  )

protected

Definition at line 299 of file zverse.cpp.

                                                                          {

    len = (len < 0) ? strlen(buf) : len;
    if (!testmt) 
        testmt = ((idxfp[0]) ? 1:2);
    if ((!dirtyCache) || (cacheBufIdx < 0)) {
        cacheBufIdx = idxfp[testmt-1]->seek(0, SEEK_END) / 12;
        cacheTestament = testmt;
        if (cacheBuf)
            free(cacheBuf);
        cacheBuf = (char *)calloc(len + 1, 1);
    }
    else cacheBuf = (char *)((cacheBuf)?realloc(cacheBuf, strlen(cacheBuf)+(len + 1)):calloc((len + 1), 1));

    dirtyCache = true;

    SW_u32 start;
    SW_u16 size;
    SW_u32 outBufIdx = (SW_u32)cacheBufIdx;

    idxoff *= 10;
    size = len;

    start = (SW_u32)strlen(cacheBuf);

    if (!size)
        start = outBufIdx = 0;

    outBufIdx = archtosword32(outBufIdx);
    start  = archtosword32(start);
    size   = archtosword16(size);

    compfp[testmt-1]->seek(idxoff, SEEK_SET);
    compfp[testmt-1]->write(&outBufIdx, 4);
    compfp[testmt-1]->write(&start, 4);
    compfp[testmt-1]->write(&size, 2);
    strcat(cacheBuf, buf);
}

void zVerse::findOffset	(	char	testmt,
		long	idxoff,
		long *	start,
		unsigned short *	size,
		unsigned long *	buffnum
	)		const

Definition at line 150 of file zverse.cpp.

{
    SW_u32 ulBuffNum    = 0;              // buffer number
    SW_u32 ulVerseStart = 0;           // verse offset within buffer
    SW_u16 usVerseSize  = 0;           // verse size
    // set start to offset in
    // set size to
    // set
    *start = *size = *buffnum = 0;
    //fprintf(stderr, "Finding offset %ld\n", idxoff);
    idxoff *= 10;
    if (!testmt) {
        testmt = ((idxfp[0]) ? 1:2);
    }
    
    // assert we have and valid file descriptor
    if (compfp[testmt-1]->getFd() < 1)
        return;
        
    long newOffset = compfp[testmt-1]->seek(idxoff, SEEK_SET);
    if (newOffset == idxoff) {
        if (compfp[testmt-1]->read(&ulBuffNum, 4) != 4) {
            fprintf(stderr, "Error reading ulBuffNum\n");
            return;
        }
    }
    else return;    
    
    if (compfp[testmt-1]->read(&ulVerseStart, 4) < 2)
    {
        fprintf(stderr, "Error reading ulVerseStart\n");
        return;
    }
    if (compfp[testmt-1]->read(&usVerseSize, 2) < 2)
    {
        fprintf(stderr, "Error reading usVerseSize\n");
        return;
    }

    *buffnum = swordtoarch32(ulBuffNum);
    *start = swordtoarch32(ulVerseStart);
    *size = swordtoarch16(usVerseSize);

}

void zVerse::flushCache ( ) const

protected

Definition at line 339 of file zverse.cpp.

                              {
    if (dirtyCache) {
        SW_u32 idxoff;
        SW_u32 start, outstart;
        SW_u32 size, outsize;
        SW_u32 zsize, outzsize;

        idxoff = (SW_u32)cacheBufIdx * 12;
        if (cacheBuf) {
            size = outsize = zsize = outzsize = (SW_u32)strlen(cacheBuf);
            if (size) {
    //          if (compressor) {
    //              delete compressor;
    //              compressor = new LZSSCompress();
    //          }
                compressor->setUncompressedBuf(cacheBuf);
                unsigned long tmpSize;
                compressor->getCompressedBuf(&tmpSize);
                outzsize = zsize = (SW_u32)tmpSize;

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

                start = outstart = (SW_u32)textfp[cacheTestament - 1]->seek(0, SEEK_END);

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

                textfp[cacheTestament-1]->write(buf, zsize);

                idxfp[cacheTestament-1]->seek(idxoff, SEEK_SET);
                idxfp[cacheTestament-1]->write(&outstart, 4);
                idxfp[cacheTestament-1]->write(&outzsize, 4);
                idxfp[cacheTestament-1]->write(&outsize, 4);
            }
            free(cacheBuf);
            cacheBuf = 0;
        }
        dirtyCache = false;
    }
}

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

inlinevirtual

Reimplemented in zText, and zCom.

Definition at line 70 of file zverse.h.

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

void zVerse::zReadText	(	char	testmt,
		long	start,
		unsigned short	size,
		unsigned long	buffnum,
		SWBuf &	buf
	)		const

Definition at line 206 of file zverse.cpp.

                                                                                                                {
    SW_u32 ulCompOffset = 0;           // compressed buffer start
    SW_u32 ulCompSize   = 0;                 // buffer size compressed
    SW_u32 ulUnCompSize = 0;              // buffer size uncompressed

    if (!testmt) {
        testmt = ((idxfp[0]) ? 1:2);
    }
    
    // assert we have and valid file descriptor
    if (compfp[testmt-1]->getFd() < 1)
        return;
    
    if (size && 
        !(((long) ulBuffNum == cacheBufIdx) && (testmt == cacheTestament) && (cacheBuf))) {
        //fprintf(stderr, "Got buffer number{%ld} versestart{%ld} versesize{%d}\n", ulBuffNum, ulVerseStart, usVerseSize);

        if (idxfp[testmt-1]->seek(ulBuffNum*12, SEEK_SET)!=(long) ulBuffNum*12)
        {
            fprintf(stderr, "Error seeking compressed file index\n");
            return;
        }
        if (idxfp[testmt-1]->read(&ulCompOffset, 4)<4)
        {
            fprintf(stderr, "Error reading ulCompOffset\n");
            return;
        }
        if (idxfp[testmt-1]->read(&ulCompSize, 4)<4)
        {
            fprintf(stderr, "Error reading ulCompSize\n");
            return;
        }
        if (idxfp[testmt-1]->read(&ulUnCompSize, 4)<4)
        {
            fprintf(stderr, "Error reading ulUnCompSize\n");
            return;
        }

        ulCompOffset  = swordtoarch32(ulCompOffset);
        ulCompSize  = swordtoarch32(ulCompSize);
        ulUnCompSize  = swordtoarch32(ulUnCompSize);

        if (textfp[testmt-1]->seek(ulCompOffset, SEEK_SET)!=(long)ulCompOffset)
        {
            fprintf(stderr, "Error: could not seek to right place in compressed text\n");
            return;
        }
        SWBuf pcCompText;
        pcCompText.setSize(ulCompSize+5);

        if (textfp[testmt-1]->read(pcCompText.getRawData(), ulCompSize)<(long)ulCompSize) {
            fprintf(stderr, "Error reading compressed text\n");
            return;
        }
        pcCompText.setSize(ulCompSize);
        rawZFilter(pcCompText, 0); // 0 = decipher
        
        unsigned long bufSize = ulCompSize;
        compressor->setCompressedBuf(&bufSize, pcCompText.getRawData());

        if (cacheBuf) {
            flushCache();
            free(cacheBuf);
        }
        
        unsigned long len = 0;
        compressor->setUncompressedBuf(0, &len);
        cacheBuf = (char *)calloc(len + 1, 1);
        memcpy(cacheBuf, compressor->getUncompressedBuf(), len);
        cacheBufSize = (int)strlen(cacheBuf);  // TODO: can we just use len?
        cacheTestament = testmt;
        cacheBufIdx = ulBuffNum;
    }   
    
    inBuf = "";
    if ((size > 0) && cacheBuf && ((unsigned)start < cacheBufSize)) {
        inBuf.setFillByte(0);
        inBuf.setSize(size+1);
        strncpy(inBuf.getRawData(), &(cacheBuf[start]), size);
        inBuf.setSize(strlen(inBuf.c_str()));
    }
}

Member Data Documentation

char* zVerse::cacheBuf

mutableprotected

Definition at line 50 of file zverse.h.

long zVerse::cacheBufIdx

mutableprotected

Definition at line 53 of file zverse.h.

unsigned int zVerse::cacheBufSize

mutableprotected

Definition at line 51 of file zverse.h.

char zVerse::cacheTestament

mutableprotected

Definition at line 52 of file zverse.h.

FileDesc* zVerse::compfp[2]

protected

Definition at line 45 of file zverse.h.

SWCompress* zVerse::compressor

private

Definition at line 38 of file zverse.h.

bool zVerse::dirtyCache

mutableprotected

Definition at line 54 of file zverse.h.

FileDesc* zVerse::idxfp[2]

protected

Definition at line 43 of file zverse.h.

SWORD_NAMESPACE_START int zVerse::instance = 0

staticprotected

Definition at line 41 of file zverse.h.

char* zVerse::path

protected

Definition at line 46 of file zverse.h.

FileDesc* zVerse::textfp[2]

protected

Definition at line 44 of file zverse.h.

const char zVerse::uniqueIndexID = {'X', 'r', 'v', 'c', 'b'}

static

Definition at line 62 of file zverse.h.

---

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

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