The Sword Project: swmodule.h Source File

swmodule.h

/******************************************************************************
 *  swmodule.h  - code for base class 'module'.  Module is the basis for all
 *                types of modules (e.g. texts, commentaries, maps, lexicons,
 *                etc.)
 *
 * $Id: swmodule.h 2093 2007-09-28 19:20:22Z scribe $
 *
 * 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 SWMODULE_H
#define SWMODULE_H

#include <swdisp.h>
#include <listkey.h>
#include <swconfig.h>

#include <swcacher.h>
#include <swsearchable.h>

#include <list>

#include <defs.h>

SWORD_NAMESPACE_START

class SWOptionFilter;
class SWFilter;

#define SEARCHFLAG_MATCHWHOLEENTRY 4096

#define SWMODULE_OPERATORS \
        operator const char *() { return RenderText(); } \
        operator SWKey &() { return *getKey(); } \
        operator SWKey *() { return getKey(); } \
        SWModule &operator <<(const char *inbuf) { setEntry(inbuf); return *this; } \
        SWModule &operator <<(const SWKey *sourceKey) { linkEntry(sourceKey); return *this; } \
        SWModule &operator -=(int steps) { decrement(steps); return *this; } \
        SWModule &operator +=(int steps) { increment(steps); return *this; } \
        SWModule &operator ++(int) { return *this += 1; } \
        SWModule &operator --(int) { return *this -= 1; } \
        SWModule &operator =(SW_POSITION p) { setPosition(p); return *this; }


typedef std::list < SWFilter * >FilterList;
typedef std::list < SWOptionFilter * >OptionFilterList;
typedef std::map < SWBuf, SWBuf, std::less < SWBuf > > AttributeValue;
typedef std::map < SWBuf, AttributeValue, std::less < SWBuf > > AttributeList;
typedef std::map < SWBuf, AttributeList, std::less < SWBuf > > AttributeTypeList;

#define SWTextDirection char
#define SWTextEncoding char
#define SWTextMarkup char

// TODO: should all SWModule decendents be SWCachers?  Only some really
// cache data.  But if we don't do this, then we need another mechanism to
// check if we are an SWCacher.  Maybe make SWModule extend SWObject (which
// it probably should anyway.  But then we need to add all the cheezy
// heirarchy info to all he decendent classes for our SWDYNAMIC_CAST and
// then we can see if we implement SWCacher so we know whether or not to add
// to the yet to be developed cachemgr.
// Just leave for now.  This lets us always able to call module->flush()
// to manually flush a cache, and doesn't hurt if there is no work done.

class SWDLLEXPORT SWModule : public SWCacher, public SWSearchable {

protected:

        ConfigEntMap ownConfig;
        ConfigEntMap *config;
        mutable AttributeTypeList entryAttributes;
        mutable bool procEntAttr;

        char error;
        bool skipConsecutiveLinks;

        SWKey *key;

        ListKey listKey;
        char *modname;
        char *moddesc;
        char *modtype;
        char *modlang;  

        char direction;
        char markup;
        char encoding;

        SWDisplay *disp;

        static SWDisplay rawdisp;
        SWBuf entryBuf;

        FilterList *stripFilters;

        FilterList *rawFilters;

        FilterList *renderFilters;

        OptionFilterList *optionFilters;

        FilterList *encodingFilters;

        int entrySize;
        mutable long entryIndex;         // internal common storage for index


public:

        bool terminateSearch;

        SWModule(const char *imodname = 0, const char *imoddesc = 0, SWDisplay * idisp = 0, char *imodtype = 0, SWTextEncoding encoding = ENC_UNKNOWN, SWTextDirection dir = DIRECTION_LTR, SWTextMarkup markup = FMT_UNKNOWN, const char* modlang = 0);

        virtual ~SWModule();

        virtual char Error();

        virtual const bool isUnicode() const { return (encoding == (char)ENC_UTF8 || encoding == (char)ENC_SCSU); }

        // These methods are useful for modules that come from a standard SWORD install (most do).
        // SWMgr will call setConfig.  The user may use getConfig and getConfigEntry (if they
        // are not comfortable with, or don't wish to use  stl maps).
        virtual void setConfig(ConfigEntMap *config);
        virtual const ConfigEntMap &getConfig() const { return *config; }
        virtual const char *getConfigEntry(const char *key) const;

        virtual const int getEntrySize() const { return entrySize; }

        virtual char setKey(const SWKey *ikey);

        char setKey(const SWKey &ikey) { return setKey(&ikey); }
        char SetKey(const SWKey *ikey) { return setKey(ikey); }
        char SetKey(const SWKey &ikey) { return setKey(ikey); }
        char Key(const SWKey & ikey) { return setKey(ikey); }

        virtual SWKey *getKey() const;
        SWKey &Key() const { return *getKey(); }

        virtual const char *KeyText(const char *ikeytext = 0) {
                if (ikeytext) setKey(ikeytext);
                return *getKey();
        }

        virtual const char *getKeyText() const {
                return *getKey();
        }

        
        virtual long Index() const { return entryIndex; }
        virtual long Index(long iindex) { entryIndex = iindex; return entryIndex; }

        virtual char Display();

        virtual SWDisplay *getDisplay() const;

        virtual void setDisplay(SWDisplay * idisp);

        SWDisplay *Disp(SWDisplay * idisp = 0) {
                if (idisp)
                        setDisplay(idisp);
                return getDisplay();
        }

        virtual char *Name() const;

        virtual char *Name(const char *imodname);

        virtual char *Description() const;

        virtual char *Description(const char *imoddesc);

        virtual char *Type() const;

        virtual char *Type(const char *imodtype);

        virtual char Direction(signed char newdir = -1);

        virtual char Encoding(signed char enc = -1);

        virtual char Markup(signed char markup = -1);

        virtual char *Lang(const char *imodlang = 0);


        // search interface -------------------------------------------------

        virtual ListKey &search(const char *istr, int searchType = 0, int flags = 0,
                        SWKey * scope = 0,
                        bool * justCheckIfSupported = 0,
                        void (*percent) (char, void *) = &nullPercent,
                        void *percentUserData = 0);

        // for backward compat-- deprecated
        virtual ListKey &Search(const char *istr, int searchType = 0, int flags = 0,
                        SWKey * scope = 0,
                        bool * justCheckIfSupported = 0,
                        void (*percent) (char, void *) = &nullPercent,
                        void *percentUserData = 0) {
                return search(istr, searchType, flags, scope, justCheckIfSupported, percent, percentUserData);
        }


        virtual SWKey *CreateKey();

        virtual SWBuf &getRawEntryBuf() = 0;

        virtual const char *getRawEntry() { return getRawEntryBuf().c_str(); }

        // write interface ----------------------------
        virtual bool isWritable() { return false; }

        static signed char createModule(const char *path);

        virtual void setEntry(const char *inbuf, long len= -1);

        virtual void linkEntry(const SWKey *sourceKey);

        virtual void deleteEntry() {}

        // end write interface ------------------------

        virtual void decrement(int steps = 1);

        virtual void increment(int steps = 1);

        virtual void setPosition(SW_POSITION pos);

        virtual void filterBuffer(OptionFilterList *filters, SWBuf &buf, SWKey *key);

        virtual void filterBuffer(FilterList *filters, SWBuf &buf, SWKey *key);

        virtual SWModule &AddRenderFilter(SWFilter *newfilter) {
                renderFilters->push_back(newfilter);
                return *this;
        }

        virtual const FilterList &getRenderFilters() const {
                return *renderFilters;
        }

        virtual SWModule &RemoveRenderFilter(SWFilter *oldfilter) {
                renderFilters->remove(oldfilter);
                return *this;
        }

        virtual SWModule &ReplaceRenderFilter(SWFilter *oldfilter, SWFilter *newfilter) {
                FilterList::iterator iter;
                for (iter = renderFilters->begin(); iter != renderFilters->end(); iter++) {
                        if (*iter == oldfilter)
                                *iter = newfilter;
                }
                return *this;
        }

        virtual void renderFilter(SWBuf &buf, SWKey *key) {
                filterBuffer(renderFilters, buf, key);
        }

        virtual SWModule &AddEncodingFilter(SWFilter *newfilter) {
                encodingFilters->push_back(newfilter);
                return *this;
        }

        virtual SWModule &RemoveEncodingFilter(SWFilter *oldfilter) {
                encodingFilters->remove(oldfilter);
                return *this;
        }

        virtual SWModule &ReplaceEncodingFilter(SWFilter *oldfilter, SWFilter *newfilter) {
                FilterList::iterator iter;
                for (iter = encodingFilters->begin(); iter != encodingFilters->end(); iter++) {
                        if (*iter == oldfilter)
                                *iter = newfilter;
                }
                return *this;
        }

        virtual void encodingFilter(SWBuf &buf, SWKey *key) {
                filterBuffer(encodingFilters, buf, key);
        }

        virtual SWModule &AddStripFilter(SWFilter *newfilter) {
                stripFilters->push_back(newfilter);
                return *this;
        }

        virtual SWModule &AddRawFilter(SWFilter *newfilter) {
                rawFilters->push_back(newfilter);
                return *this;
        }

        virtual void stripFilter(SWBuf &buf, SWKey *key) {
                filterBuffer(stripFilters, buf, key);
        }


        virtual void rawFilter(SWBuf &buf, SWKey *key) {
                filterBuffer(rawFilters, buf, key);
        }

        virtual SWModule &AddOptionFilter(SWOptionFilter *newfilter) {
                optionFilters->push_back(newfilter);
                return *this;
        }

        virtual void optionFilter(SWBuf &buf, SWKey *key) {
                filterBuffer(optionFilters, buf, key);
        }

        virtual const char *StripText(const char *buf = 0, int len = -1);

        virtual const char *RenderText(const char *buf = 0, int len = -1, bool render = true);

        virtual const char *StripText(SWKey *tmpKey);

        virtual const char *RenderText(SWKey *tmpKey);

        virtual void setSkipConsecutiveLinks(bool val) { skipConsecutiveLinks = val; }

        virtual bool getSkipConsecutiveLinks() { return skipConsecutiveLinks; }

        virtual AttributeTypeList &getEntryAttributes() const { return entryAttributes; }

        virtual void processEntryAttributes(bool val) const { procEntAttr = val; }

        virtual bool isProcessEntryAttributes() const { return procEntAttr; }

        // OPERATORS -----------------------------------------------------------------
        
        virtual signed char createSearchFramework(
                        void (*percent) (char, void *) = &nullPercent,
                        void *percentUserData = 0);
        virtual void deleteSearchFramework();
        virtual bool hasSearchFramework();

        SWMODULE_OPERATORS

};

SWORD_NAMESPACE_END
#endif

The SWORD Project; P. O. Box 2528; Tempe, AZ 85280-2528 USA