versekey.h

Go to the documentation of this file.

/******************************************************************************
 *
 * versekey.h -     class 'VerseKey': an SWKey for biblical verses with a
 *          book ch:vs structure.  Includes a freehand text
 *          parser for the many ways one might specify a biblical
 *          verse reference or reference range / list.
 *
 * $Id: versekey.h 3820 2020-10-24 20:27:30Z scribe $
 *
 * Copyright 1997-2013 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 <versificationmgr.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)



class SWDLLEXPORT VerseKey : public SWKey {

private:
    static int instance;
    ListKey internalListKey;

    const VersificationMgr::System *refSys;

    char autonorm;

    char intros;

    void init(const char *v11n = "KJV");

    // bounds caching is mutable, thus const
    void initBounds() const;

    // private with no bounds check
    void setFromOther(const VerseKey &vk);

    void checkBounds();

    // internal upper/lower bounds optimizations
    mutable long lowerBound, upperBound;    // if autonorms is on
    mutable VerseKey *tmpClone;

    typedef struct { int test; int book; int chap; int verse; char suffix; } VerseComponents;

    mutable VerseComponents lowerBoundComponents, upperBoundComponents; // if autonorms is off, we can't optimize with index

protected:

    signed char testament;
    signed char book;
    signed int chapter;
    signed int verse;
    signed char suffix;

    /************************************************************************
     * VerseKey::getBookFromAbbrev - Attempts to find a book no from a name or
     *                           abbreviation
     *
     * ENT: @param abbr - key for which to search;
     * RET: @return book number or < 0 = not valid
     */
    virtual int getBookFromAbbrev(const char *abbr) const;

    void freshtext() const;
    virtual char parse(bool checkNormalize = true);
public:
    int BMAX[2];

    VerseKey(const char *ikey = 0);

    VerseKey(const SWKey *ikey);

    VerseKey(const char *min, const char *max, const char *v11n = "KJV");

    VerseKey(const SWKey &k);

    VerseKey(const VerseKey &k);

    virtual ~VerseKey();

    void setLowerBound(const VerseKey &lb);
    SWDEPRECATED VerseKey &LowerBound(const VerseKey &lb) { setLowerBound(lb); return getLowerBound(); }

    void setUpperBound(const VerseKey &ub);
    SWDEPRECATED VerseKey &UpperBound(const VerseKey &ub) { setUpperBound(ub); return getUpperBound(); }

    VerseKey &getLowerBound() const;
    SWDEPRECATED VerseKey &LowerBound() const { return getLowerBound(); }

    VerseKey &getUpperBound() const;
    SWDEPRECATED VerseKey &UpperBound() const { return getUpperBound(); }

    void clearBounds() const;
    SWDEPRECATED void ClearBounds() { clearBounds(); }

    virtual SWKey *clone() const;

    virtual const char *getText() const;
    virtual const char *getShortText() const;
    virtual void setText(const char *ikey, bool checkNormalize) { SWKey::setText(ikey); parse(checkNormalize); }
    virtual void setText(const char *ikey) { SWKey::setText(ikey); parse(); }
    virtual void copyFrom(const SWKey &ikey);

    virtual void copyFrom(const VerseKey &ikey);

    virtual void positionFrom(const SWKey &ikey);

    virtual void setPosition(SW_POSITION newpos);

    virtual void decrement(int steps = 1);

    virtual void increment(int steps = 1);
    virtual bool isTraversable() const { return true; }

    virtual const char *getBookName() const;
    virtual void setBookName(const char *bname);

    virtual const char *getBookAbbrev() const;
    virtual char getTestament() const;
    SWDEPRECATED char Testament() const { return getTestament(); }  // deprecated
    virtual int getTestamentMax() const { return 2; }

    virtual char getBook() const;
    SWDEPRECATED char Book() const { return getBook(); }    // deprecated
    virtual int getBookMax() const { return BMAX[testament-1]; }

    virtual int getChapter() const;
    SWDEPRECATED int Chapter() const { return getChapter(); }   // deprecated
    virtual int getChapterMax() const;

    virtual int getVerse() const;
    SWDEPRECATED int Verse() const { return getVerse(); }       // deprecated
    virtual int getVerseMax() const;

    virtual char getSuffix() const;

    virtual void setTestament(char itestament);
    SWDEPRECATED char Testament(char itestament) { char retVal = getTestament(); setTestament(itestament); return retVal; } // deprecated

    virtual void setBook(char ibook);
    SWDEPRECATED char Book(char ibook) { char retVal = getBook(); setBook(ibook); return retVal; } // deprecated

    virtual void setChapter(int ichapter);
    SWDEPRECATED int Chapter(int ichapter) { char retVal = getChapter(); setChapter(ichapter); return retVal; } // deprecated

    virtual void setVerse(int iverse);
    SWDEPRECATED int Verse(int iverse) { char retVal = getVerse(); setVerse(iverse); return retVal; } // deprecated;

    virtual void setSuffix(char isuffix);

    virtual void normalize(bool autocheck = false);
    SWDEPRECATED void Normalize(char autocheck = 0) { normalize(autocheck!=0); }

    virtual void setAutoNormalize(bool iautonorm);
    virtual bool isAutoNormalize() const;

    SWDEPRECATED char AutoNormalize(char iautonorm) { char retVal = isAutoNormalize()?1:0; setAutoNormalize(iautonorm!=0); return retVal; } // deprecated
    SWDEPRECATED char AutoNormalize() const { return isAutoNormalize()?1:0; }   // deprecated


    SWDEPRECATED char Headings(char iheadings = MAXPOS(char)) { char retVal = isIntros(); if (iheadings != MAXPOS(char)) setIntros(iheadings!=0); return retVal; }

    virtual void setIntros(bool val);
    virtual bool isIntros() const;


    virtual long getIndex() const;


    virtual void setIndex(long iindex);


    virtual long getTestamentIndex() const;

    SWDEPRECATED long TestamentIndex() const { return getTestamentIndex(); }    // deprecated, use getTestamentIndex()

    virtual const char *getOSISRef() const;
    virtual const char *getOSISBookName() const;

    static const char *convertToOSIS(const char *inRef, const SWKey *defaultKey);

    /******************************************************************************
     * VerseKey::parseVerseList - Attempts to parse a buffer into separate
     *              verse entries returned in a ListKey
     *
     * ENT: buf     - buffer to parse;
     *  defaultKey  - if verse, chap, book, or testament is left off,
     *              pull info from this key (ie. Gen 2:3; 4:5;
     *              Gen would be used when parsing the 4:5 section)
     *  expandRange - whether or not to expand eg. John 1:10-12 or just
     *              save John 1:10
     *
     * RET: ListKey reference filled with verse entries contained in buf
     *
     * COMMENT: This code works but wreaks.  Rewrite to make more maintainable.
     */
    virtual ListKey parseVerseList(const char *buf, const char *defaultKey = 0, bool expandRange = false, bool useChapterAsVerse = false);
    SWDEPRECATED ListKey ParseVerseList(const char *buf, const char *defaultKey = 0, bool expandRange = false, bool useChapterAsVerse = false) { return parseVerseList(buf, defaultKey, expandRange, useChapterAsVerse); }
    virtual const char *getRangeText() const;
    virtual const char *getShortRangeText() const;
    virtual const char *getOSISRefRangeText() const;
    virtual int compare(const SWKey &ikey);

    virtual int _compare(const VerseKey &ikey);

    virtual void setVersificationSystem(const char *name);
    virtual const char *getVersificationSystem() const;

    // DEBUG
    void validateCurrentLocale() const;


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


    SWKEY_OPERATORS

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

SWORD_NAMESPACE_END

#endif //VERSEKEY_H