---

versekey.h

/******************************************************************************
 *      versekey.h - code for class 'versekey'- a standard Biblical verse key
 *
 * $Id: versekey_8h-source.html,v 1.1 2003/02/28 21:22:23 mgruner Exp $
 *
 * Copyright 1998 CrossWire Bible Society (http://www.crosswire.org)
 *      CrossWire Bible Society
 *      P. O. Box 2528
 *      Tempe, AZ       85280-2528
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation version 2.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License for more details.
 *
 */


#ifndef VERSEKEY_H
#define VERSEKEY_H

#include <swkey.h>
#include <swmacs.h>
#include <listkey.h>
#include <ctype.h>

#include <defs.h>

SWORD_NAMESPACE_START

#define POS_MAXVERSE ((char)3)
#define POS_MAXCHAPTER ((char)4)
#define POS_MAXBOOK ((char)5)

#define MAXVERSE SW_POSITION(POS_MAXVERSE)
#define MAXCHAPTER SW_POSITION(POS_MAXCHAPTER)
#define MAXBOOK SW_POSITION(POS_MAXBOOK)

struct sbook
{
        const char *name;

        const char *prefAbbrev;

        unsigned char chapmax;
        int *versemax;
};

struct abbrev
{
        const char *ab;
        int book;
};


class SWLocale;

class SWDLLEXPORT VerseKey:public SWKey
{
        class LocaleCache
        {
        public:
                char *name;
                unsigned int abbrevsCnt;
                SWLocale *locale;
                        LocaleCache()
                {
                        name = 0;
                        abbrevsCnt = 0;
                        locale = 0;
                }
                 virtual ~LocaleCache()
                {
                        if (name)
        delete[]name;
                }
        };

        static SWClass classdef;

        static long *offsets[2][2];
        static int offsize[2][2];
        static int instance;
        static struct sbook otbooks[];
        static struct sbook ntbooks[];
        static long otbks[];
        static long otcps[];
        static long ntbks[];
        static long ntcps[];
        static int vm[];
        static LocaleCache localeCache;
        ListKey internalListKey;

        const struct abbrev *abbrevs;
        char *locale;
        int abbrevsCnt;
        signed char testament;
        mutable signed char book;
        mutable signed int chapter;
        mutable signed int verse;
        char autonorm;
        char headings;

        int getBookAbbrev(const char *abbr);
        void initBounds() const;
        void initstatics();
        void init();
        void freshtext() const;
        virtual char parse();
        int findindex(long *array, int size, long value);
        mutable VerseKey *lowerBound, *upperBound;

public:
        static const char builtin_BMAX[2];
        static struct sbook *builtin_books[2];
        static const struct abbrev builtin_abbrevs[];
        const char *BMAX;
        struct sbook **books;

        VerseKey(const char *ikey = 0);
        
        VerseKey(const SWKey * ikey);
        
        VerseKey(const char *min, const char *max);
        
        VerseKey(const VerseKey &k);
        
        virtual ~ VerseKey();

        VerseKey & LowerBound(const char *lb);
        
        VerseKey & UpperBound(const char *ub);
        
        VerseKey & LowerBound() const;
        
        VerseKey & UpperBound() const;
        
        void ClearBounds();
        
        virtual SWKey *clone() const;
        
        virtual const char *getText() const;
        virtual const char *getShortText() const;
        virtual void setText(const char *ikey) { SWKey::setText(ikey); parse (); }
        virtual void copyFrom(const SWKey & ikey);
        
        virtual void copyFrom(const VerseKey & ikey);
        
        virtual void setPosition(SW_POSITION newpos);
        
        virtual void decrement(int steps);
        
        virtual void increment(int steps);
        virtual char Traversable() { return 1; }

        virtual const char *getBookName() const;
        virtual const char *getBookAbbrev() const;
        virtual char Testament() const;
        
        virtual char Book() const;
        
        virtual int Chapter() const;
        
        virtual int Verse() const;
        
        virtual char Testament(char itestament);
        
        virtual char Book(char ibook);
        
        virtual int Chapter(int ichapter);
        
        virtual int Verse(int iverse);
        
        virtual void Normalize(char autocheck = 0);
        
        virtual char AutoNormalize(char iautonorm = MAXPOS (char));
        
        virtual char Headings(char iheadings = MAXPOS (char));
        
        virtual long NewIndex() const;
        
        virtual long Index() const;
        
        virtual long Index(long iindex);

        virtual const char *getOSISRef() const;

        virtual ListKey ParseVerseList(const char *buf, const char *defaultKey = "Genesis 1:1", bool expandRange = false);
        virtual const char *getRangeText() const;
        virtual int compare(const SWKey & ikey);
        
        virtual int _compare(const VerseKey & ikey);
        
        virtual void setBookAbbrevs(const struct abbrev *bookAbbrevs, unsigned int size = 0 /* default determine size */ );
        virtual void setBooks(const char *iBMAX, struct sbook **ibooks);
        virtual void setLocale(const char *name);
        virtual const char *getLocale() const { return locale; }



        // OPERATORS --------------------------------------------------------------------


        SWKEY_OPERATORS

        virtual SWKey & operator = (const VerseKey & ikey) { copyFrom(ikey); return *this; }
};

SWORD_NAMESPACE_END
#endif

---