swkey.h

Go to the documentation of this file.

/******************************************************************************
 *
 * swkey.h -    class SWKey:  SWKey is the basis for all indexing into modules
 *      (e.g. verses, table of contents tree, strings, etc.)
 *
 * $Id: swkey.h 3828 2020-11-24 23:15:44Z scribe $
 *
 * Copyright 1998-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 SWKEY_H
#define SWKEY_H

#include <swobject.h>

#include <defs.h>
#include <sysdata.h>
#include <utilstr.h>

SWORD_NAMESPACE_START

#define KEYERR_OUTOFBOUNDS 1

#define SWKEY_OPERATORS \
    SWKey &operator =(const char *ikey) { setText(ikey); return *this; } \
    SWKey &operator =(const SWKey &ikey) { positionFrom(ikey); return *this; } \
    SWKey &operator =(SW_POSITION pos) { setPosition(pos); return *this; } \
    operator const char *() const { return getText(); } \
    bool operator ==(const SWKey &ikey) { return equals(ikey); } \
    bool operator !=(const SWKey &ikey) { return !equals(ikey); } \
    virtual bool operator >(const SWKey &ikey) { return (compare(ikey) > 0); } \
    virtual bool operator <(const SWKey &ikey) { return (compare(ikey) < 0); } \
    virtual bool operator >=(const SWKey &ikey) { return (compare(ikey) > -1); } \
    virtual bool operator <=(const SWKey &ikey) { return (compare(ikey) < 1); } \
    SWKey &operator -=(int steps) { decrement(steps); return *this; } \
    SWKey &operator +=(int steps) { increment(steps); return *this; } \
    SWKey &operator ++()    { increment(1); return *this; } \
    SWKey  operator ++(int) { SWKey temp = *this; increment(1); return temp; } \
    SWKey &operator --()    { decrement(1); return *this; } \
    SWKey  operator --(int) { SWKey temp = *this; decrement(1); return temp; }


class SW_POSITION {
    char pos;
public:
    SW_POSITION(char ipos) { pos = ipos; }
    operator char() { return pos; }
};

#define POS_TOP ((char)1)
#define POS_BOTTOM ((char)2)

#define TOP SW_POSITION(POS_TOP)
#define BOTTOM SW_POSITION(POS_BOTTOM)

class SWLocale;

class SWDLLEXPORT SWKey : public SWObject {

    class LocaleCache {
    public:
        char *name;
        SWLocale *locale;
            LocaleCache() {
            name = 0;
            locale = 0;
        }
         virtual ~LocaleCache() {
            if (name)
            delete[]name;
        }
    };
    static LocaleCache localeCache;
    // for caching; don't use directly, call getPrivateLocale()
    mutable SWLocale *locale;


    long index;
    void init();


protected:
    char *keytext;
    mutable char *rangeText;
    mutable bool boundSet;
    bool persist;
    mutable char error;

    char *localeName;
    SWLocale *getPrivateLocale() const;


public:

    // misc storage for whatever
    SW_u64 userData;

    SWKey(const char *ikey = 0);

    SWKey(const SWKey &k);

    virtual ~SWKey();

    virtual SWKey *clone() const;


    bool isPersist() const;
    SWDEPRECATED char Persist() const { return isPersist(); }

    void setPersist(bool ipersist);
    SWDEPRECATED char Persist(signed char ipersist) { setPersist(ipersist!=0); return isPersist(); }

    virtual char popError();
    virtual char getError() const { return error; }
    virtual void setError(char err) { error = err; }
    SWDEPRECATED char Error() { return popError(); }

    virtual void setText(const char *ikey);

    virtual void copyFrom(const SWKey &ikey);
    virtual void positionFrom(const SWKey &ikey) { copyFrom(ikey); }

    virtual const char *getText() const;
    virtual const char *getShortText() const { return getText(); }
    virtual const char *getRangeText() const;
    virtual const char *getShortRangeText() const { return getRangeText(); }
    virtual const char *getOSISRefRangeText() const;
    virtual bool isBoundSet() const { return boundSet; }
    virtual void clearBounds() const { boundSet = false; }

    virtual int compare(const SWKey &ikey);

    virtual bool equals(const SWKey &ikey) { return !compare(ikey); }

    virtual void setPosition(SW_POSITION);

    virtual void decrement(int steps = 1);

    virtual void increment(int steps = 1);

    virtual bool isTraversable() const { return false; }

    char *getLocale() const { return localeName; }
    void setLocale(const char *name) { stdstr(&localeName, name); locale = 0;   } // this will force an on demand lookup of our locale

    virtual long getIndex() const { return index; }

    virtual void setIndex(long iindex) { index = iindex; }

    SWKEY_OPERATORS

    };

SWORD_NAMESPACE_END
#endif