VersificationMgr::System Class Reference

#include <versificationmgr.h>

Collaboration diagram for VersificationMgr::System:

Classes
class	Private

Public Member Functions
const int *	getBMAX () const
const Book *	getBook (int number) const
const Book *	getBookByName (const char *bookName) const
int	getBookCount () const
int	getBookNumberByOSISName (const char *bookName) const
const char *	getName () const
long	getNTStartOffset () const
long	getOffsetFromVerse (int book, int chapter, int verse) const
char	getVerseFromOffset (long offset, int *book, int *chapter, int *verse) const
void	loadFromSBook (const sbook *ot, const sbook *nt, int *chMax, const unsigned char *mappings=NULL)
System &	operator= (const System &other)
	System ()
	System (const System &other)
	System (const char *name)
void	translateVerse (const System *dstSys, const char **book, int *chapter, int *verse, int *verse_end) const
	~System ()

Private Member Functions
void	init ()

Private Attributes
int	BMAX [2]
SWBuf	name
long	ntStartOffset
Private *	p

Detailed Description

Definition at line 124 of file versificationmgr.h.

Constructor & Destructor Documentation

VersificationMgr::System::System ( )

inline

Definition at line 133 of file versificationmgr.h.

{ this->name = ""; init(); }

VersificationMgr::System::System

(

const System &

other

)

Definition at line 169 of file versificationmgr.cpp.

                                                  {
    init();
    name = other.name;
    BMAX[0] = other.BMAX[0];
    BMAX[1] = other.BMAX[1];
    (*p) = *(other.p);
    ntStartOffset = other.ntStartOffset;
}

VersificationMgr::System::System ( const char *  name )

inline

Definition at line 136 of file versificationmgr.h.

{ this->name = name; init(); }

VersificationMgr::System::~System

(

)

Definition at line 189 of file versificationmgr.cpp.

                                {
    delete p;
}

Member Function Documentation

const int* VersificationMgr::System::getBMAX ( ) const

inline

Definition at line 146 of file versificationmgr.h.

{ return BMAX; };

const VersificationMgr::Book * VersificationMgr::System::getBook

(

int

number

)

const

Definition at line 194 of file versificationmgr.cpp.

                                                                            {
    return (number < (signed int)p->books.size()) ? &(p->books[number]) : 0;
}

const Book* VersificationMgr::System::getBookByName

(

const char *

bookName

)

const

int VersificationMgr::System::getBookCount

(

)

const

Definition at line 297 of file versificationmgr.cpp.

                                               {
    return (int)(p ? p->books.size() : 0);
}

int VersificationMgr::System::getBookNumberByOSISName

(

const char *

bookName

)

const

Definition at line 199 of file versificationmgr.cpp.

                                                                              {
    map<SWBuf, int>::const_iterator it = p->osisLookup.find(bookName);
    return (it != p->osisLookup.end()) ? it->second : -1;
}

const char* VersificationMgr::System::getName ( ) const

inline

Definition at line 138 of file versificationmgr.h.

{ return name.c_str(); }

long VersificationMgr::System::getNTStartOffset ( ) const

inline

Definition at line 147 of file versificationmgr.h.

{ return ntStartOffset; }

long VersificationMgr::System::getOffsetFromVerse	(	int	book,
		int	chapter,
		int	verse
	)		const

Definition at line 302 of file versificationmgr.cpp.

                                                                                      {
    long  offset = -1;
    chapter--;

    const Book *b = getBook(book);

    if (!b)                                        return -1;   // assert we have a valid book
    if ((chapter > -1) && (chapter >= (signed int)b->p->offsetPrecomputed.size())) return -1;   // assert we have a valid chapter

    offset = b->p->offsetPrecomputed[(chapter > -1)?chapter:0];
    if (chapter < 0) offset--;

/* old code
 *
    offset = offsets[testament-1][0][book];
    offset = offsets[testament-1][1][(int)offset + chapter];
    if (!(offset|verse)) // if we have a testament but nothing else.
        offset = 1;

*/

    return (offset + verse);
}

char VersificationMgr::System::getVerseFromOffset	(	long	offset,
		int *	book,
		int *	chapter,
		int *	verse
	)		const

Definition at line 327 of file versificationmgr.cpp.

                                                                                                      {

    if (offset < 1) {   // just handle the module heading corner case up front (and error case)
        (*book) = -1;
        (*chapter) = 0;
        (*verse) = 0;
        return offset;  // < 0 = error
    }

    // binary search for book
    vector<Book>::iterator b = lower_bound(p->books.begin(), p->books.end(), offset, BookOffsetLess());
    if (b == p->books.end()) b--;
    (*book)    = distance(p->books.begin(), b)+1;
    if (offset < (*(b->p->offsetPrecomputed.begin()))-((((!(*book)) || (*book)==BMAX[0]+1))?2:1)) { // -1 for chapter headings
        (*book)--;
        if (b != p->books.begin()) {
            b--;    
        }
    }
    vector<long>::iterator c = lower_bound(b->p->offsetPrecomputed.begin(), b->p->offsetPrecomputed.end(), offset);

    // if we're a book heading, we are lessthan chapter precomputes, but greater book.  This catches corner case.
    if (c == b->p->offsetPrecomputed.end()) {
        c--;
    }
    if ((offset < *c) && (c == b->p->offsetPrecomputed.begin())) {
        (*chapter) = (offset - *c)+1;   // should be 0 or -1 (for testament heading)
        (*verse) = 0;
    }
    else {
        if (offset < *c) c--;
        (*chapter) = distance(b->p->offsetPrecomputed.begin(), c)+1;
        (*verse)   = (offset - *c);
    }
    return ((*chapter > 0) && (*verse > b->getVerseMax(*chapter))) ? KEYERR_OUTOFBOUNDS : 0;
}

void VersificationMgr::System::init ( )

private

Definition at line 161 of file versificationmgr.cpp.

                                  {
    p = new Private();
    BMAX[0] = 0;
    BMAX[1] = 0;
    ntStartOffset = 0;
}

void VersificationMgr::System::loadFromSBook	(	const sbook *	ot,
		const sbook *	nt,
		int *	chMax,
		const unsigned char *	mappings = NULL
	)

Definition at line 205 of file versificationmgr.cpp.

                                                                                                                      {
    int chap = 0;
    int book = 0;
    long offset = 0;    // module heading
    offset++;           // testament heading
    while (ot->chapmax) {
        p->books.push_back(Book(ot->name, ot->osis, ot->prefAbbrev, ot->chapmax));
        offset++;       // book heading
        Book &b = p->books[p->books.size()-1];
        p->osisLookup[b.getOSISName()] = (int)p->books.size();
        for (int i = 0; i < ot->chapmax; i++) {
            b.p->verseMax.push_back(chMax[chap]);
            offset++;       // chapter heading
            b.p->offsetPrecomputed.push_back(offset);
            offset += chMax[chap++];
        }
        ot++;
        book++;
    }
    BMAX[0] = book;
    book = 0;
    ntStartOffset = offset;
    offset++;           // testament heading
    while (nt->chapmax) {
        p->books.push_back(Book(nt->name, nt->osis, nt->prefAbbrev, nt->chapmax));
        offset++;       // book heading
        Book &b = p->books[p->books.size()-1];
        p->osisLookup[b.getOSISName()] = (int)p->books.size();
        for (int i = 0; i < nt->chapmax; i++) {
            b.p->verseMax.push_back(chMax[chap]);
            offset++;       // chapter heading
            b.p->offsetPrecomputed.push_back(offset);
            offset += chMax[chap++];
        }
        nt++;
        book++;
    }
    BMAX[1] = book;

    // TODO: build offset speed array

    // parse mappings
    if (mappings != NULL) {
        const unsigned char *m=mappings;
        for (; *m != 0; m += strlen((const char*)m)+1) {
            p->mappingsExtraBooks.push_back((const char*)m);
        }
        p->mappings.resize(p->books.size()+p->mappingsExtraBooks.size());

        for (++m; *m != 0; m += 7) {
            p->mappings[m[0]-1].push_back(m);
            if (*m > p->books.size()) {
                p->mappings[m[7]-1].push_back(m);
                m += 1;
            }
        }
    }
}

VersificationMgr::System & VersificationMgr::System::operator=

(

const System &

other

)

Definition at line 179 of file versificationmgr.cpp.

                                                                              {
    name = other.name;
    BMAX[0] = other.BMAX[0];
    BMAX[1] = other.BMAX[1];
    (*p) = *(other.p);
    ntStartOffset = other.ntStartOffset;
    return *this;
}

void VersificationMgr::System::translateVerse	(	const System *	dstSys,
		const char **	book,
		int *	chapter,
		int *	verse,
		int *	verse_end
	)		const

Definition at line 434 of file versificationmgr.cpp.

                                                                                                                                   {
//dbg_mapping SWLOGD("translate verse from %s to %s: %s.%i.%i-%i\n",getName(), dstSys->getName(), *book, *chapter, *verse, *verse_end);

    if (!strcmp(getName(),"KJVA") || !strcmp(getName(),"KJV")) {
        if (!strcmp(dstSys->getName(),"KJVA") || !strcmp(dstSys->getName(),"KJV"))
            return;
        // reversed mapping
        //dbg_mapping SWLOGD("Perform reversed mapping.\n");
        int b = dstSys->getBookNumberByOSISName(*book)-1;

        //dbg_mapping SWLOGD("\tgetBookNumberByOSISName %i %s.\n", b, *book);

        if (b < 0) {
            //dbg_mapping SWLOGD("\tmappingsExtraBooks.size() %i.\n", dstSys->p->mappingsExtraBooks.size());
            for (int i=0; i<(int)dstSys->p->mappingsExtraBooks.size(); ++i) {
                //dbg_mapping SWLOGD("\t%s %s.\n", *book, dstSys->p->mappingsExtraBooks[i]);
                if (!strcmp(*book, dstSys->p->mappingsExtraBooks[i])) {
                    b = (int)p->books.size()+i-2;
                    break;
                }
            }
        }

        //dbg_mapping SWLOGD("\tb %i.\n", b);

        if (b >= (int)dstSys->p->mappings.size() || b < 0) {
            //dbg_mapping SWLOGD("no modification");
            return;
        }
        
        const unsigned char *a = NULL;
        
        // reversed mapping should use forward search for item
        for (unsigned int i=0; i<dstSys->p->mappings[b].size(); ++i) {
            const unsigned char *m = dstSys->p->mappings[b][i];

            if (m[0] != b+1) continue; // filter inter-book rules

            if (m[4] == *chapter && m[5] <= *verse) {
                //dbg_mapping SWLOGD("found mapping %i %i %i %i %i %i\n",m[1],m[2],m[3],m[4],m[5],m[6]);
                if (m[5] == *verse || (m[6] >= *verse && m[5] <= *verse)) {
                    // inside of any mapping range
                    *chapter = m[1];
                    *verse = m[2];
                    *verse_end = m[3];
                    if (*m >= dstSys->p->books.size()) {
                        SWLog::getSystemLog()->logWarning("map to extra books, possible bug source\n");
                        *book = dstSys->getBook(m[7]-1)->getOSISName();
                    }
                    return;
                }
                // destination mapping can have duplicate items, use the last (by using <=)
                if (a == NULL || (a[5]>a[6]?a[5]:a[6]) <= (m[5]>m[6]?m[5]:m[6]))
                    a = m;
            }
        }
        if (a != NULL) {
            //dbg_mapping SWLOGD("set appropriate: %i %i %i %i %i %i\n",a[1],a[2],a[3],a[4],a[5],a[6]);
            (*chapter) = a[1];
            // shift verse
            const int d = (a[3]>a[2]?a[3]:a[2])-(a[6]>a[5]?a[6]:a[5]);
            if (*verse < *verse_end)
                *verse_end += d;
            else
                *verse_end = (*verse) + d;
            *verse += d;
            if (*a > dstSys->p->books.size()) {
                //dbg_mapping SWLOGD("appropriate: %i %i %i %i %i %i %i %i\n",a[0],a[1],a[2],a[3],a[4],a[5],a[6],a[7]);
                //dbg_mapping SWLOGD("book: %s\n", dstSys->getBook(a[7]-1)->getOSISName());
                *book = dstSys->getBook(a[7]-1)->getOSISName();
            }
            return;
        }
        //dbg_mapping SWLOGD("There is no mapping.\n");
    }
    else if (strcmp(dstSys->getName(),"KJVA") && strcmp(dstSys->getName(),"KJV")) {
        const System *kjva = getSystemVersificationMgr()->getVersificationSystem("KJVA");
        const int src_verse = *verse;
        
        translateVerse(kjva, book, chapter, verse, verse_end);
        
        int interm_verse = *verse, interm_range = *verse_end, interm_chapter = *chapter;
        const char *interm_book = *book;
        
        kjva->translateVerse(dstSys, book, chapter, verse, verse_end);
        
        // contraction->expansion fix
        if (verse < verse_end && !(interm_verse < interm_range)) {
            kjva->translateVerse(this, &interm_book, &interm_chapter, &interm_verse, &interm_range);
            if (interm_verse < interm_range) {
                *verse += src_verse - interm_verse;
                if (*verse > *verse_end)
                    *verse = *verse_end;
                else
                    *verse_end = *verse;
            }
        }
    }
    else {
        //dbg_mapping SWLOGD("Perform forward mapping.\n");
        const int b = getBookNumberByOSISName(*book)-1;
        if (b >= (int)p->mappings.size())
            return;
        // forward mapping should use reversed search for item
        for (int i = (int)p->mappings[b].size()-1; i>=0; --i) {
            const unsigned char *m = p->mappings[b][i];
            if (m[1] < *chapter) {
                SWLog::getSystemLog()->logWarning("There is no mapping for this chapter.\n");
                return;
            }
            if (m[1] == *chapter && m[2] <= *verse) {
                //dbg_mapping SWLOGD("found mapping %i %i %i %i %i %i\n",m[1],m[2],m[3],m[4],m[5],m[6]);
                if (m[2] == *verse || (m[3] >= *verse && m[2] <= *verse)) {
                    *chapter = m[4];
                    *verse = m[5];
                    *verse_end = m[6];
                }
                else {
                    *chapter = m[4];
                    // shift verse
                    const int d = (m[6]>m[5]?m[6]:m[5])-(m[3]>m[2]?m[3]:m[2]);
                    if (*verse < *verse_end)
                        *verse_end += d;
                    else
                        *verse_end = (*verse) + d;
                    *verse += d;
                }
                if (*m > p->books.size())
                    *book = p->mappingsExtraBooks[m[0]-p->books.size()-1];
                return;
            }
        }
        //dbg_mapping SWLOGD("No mapping.\n");
    }
}

Member Data Documentation

int VersificationMgr::System::BMAX[2]

private

Definition at line 129 of file versificationmgr.h.

SWBuf VersificationMgr::System::name

private

Definition at line 128 of file versificationmgr.h.

long VersificationMgr::System::ntStartOffset

private

Definition at line 130 of file versificationmgr.h.

Private* VersificationMgr::System::p

private

Definition at line 126 of file versificationmgr.h.

---

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

• include/versificationmgr.h
• src/mgr/versificationmgr.cpp