---

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_8h-source.html,v 1.1 2003/02/28 21:22:05 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 SWMODULE_H
#define SWMODULE_H

#include <swdisp.h>
#include <swkey.h>
#include <listkey.h>
#include <swfilter.h>
#include <swconfig.h>
#include <swcacher.h>
#include <list>
#include <swbuf.h>

#include <defs.h>
#include <multimapwdef.h>

SWORD_NAMESPACE_START

#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::map < std::string, std::string, std::less < std::string > > AttributeValue;
typedef std::map < std::string, AttributeValue, std::less < std::string > > AttributeList;
typedef std::map < std::string, AttributeList, std::less < std::string > > AttributeTypeList;

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

enum {DIRECTION_LTR = 0, DIRECTION_RTL, DIRECTION_BIDI};
enum {FMT_UNKNOWN = 0, FMT_PLAIN, FMT_THML, FMT_GBF, FMT_HTML, FMT_HTMLHREF, FMT_RTF, FMT_OSIS};
enum {ENC_UNKNOWN = 0, ENC_LATIN1, ENC_UTF8, ENC_SCSU, ENC_UTF16, ENC_RTF, ENC_HTML};

// 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 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 {

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;

        FilterList *optionFilters;

        FilterList *encodingFilters;

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

        public:
        static void nullPercent(char percent, void *userData);
        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 const ConfigEntMap &getConfig() const { return *config; }
        virtual void setConfig(ConfigEntMap *config);
        virtual const char *getConfigEntry(const char *key) const;

        virtual const int getEntrySize() const { return entrySize; }
        char SetKey(const SWKey *ikey) { return setKey(ikey); }
        virtual char setKey(const SWKey *ikey);
        

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

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

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

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

        /******************************************************************************
         * SWModule::KeyText - Sets/gets module KeyText
         *
         * ENT: ikeytext - value which to set keytext
         *              [0] - only get
         *
         * RET: pointer to keytext
         */
        virtual const char *KeyText(const char *ikeytext = 0) {
                if (ikeytext) setKey(ikeytext);
                return *getKey();
        }

        virtual char Display();

        virtual SWDisplay *Disp(SWDisplay * idisp = 0);
        virtual char *Name(const char *imodname = 0);
        virtual char *Description(const char *imoddesc = 0);
        virtual char *Type(const char *imodtype = 0);
        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 methods

        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);
        virtual signed char createSearchFramework() { return 0; }                               // special search framework
        virtual bool hasSearchFramework() { return false; }                             // special search framework
        virtual bool isSearchOptimallySupported(const char *istr, int searchType,
                        int flags, SWKey * scope) {
                bool retVal = false;
                Search(istr, searchType, flags, scope, &retVal);
                return retVal;
        }
        virtual SWKey *CreateKey();
#ifndef SWIG 
        virtual SWBuf &getRawEntryBuf() = 0;
#else
        virtual SWBuf &getRawEntryBuf() {};
#endif  

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

        // write interface ----------------------------
        virtual bool isWritable() { return false; }
        static signed char createModule(const char *path) { return -1; }
        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 SWModule & AddRenderFilter(SWFilter * newfilter) {
                renderFilters->push_back (newfilter);
                return *this;
        }
        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 void stripFilter(SWBuf &buf, SWKey *key) {
                filterBuffer(stripFilters, buf, key);
        }
        virtual SWModule & AddRawFilter(SWFilter * newfilter) {
                rawFilters->push_back (newfilter);
                return *this;
        }
        virtual void filterBuffer(FilterList *filters, SWBuf &buf, SWKey *key) {
                FilterList::iterator it;
                for (it = filters->begin(); it != filters->end(); it++) {
                        (*it)->processText(buf, key, this);
                }
        }
        virtual void rawFilter(SWBuf &buf, SWKey *key) {
                filterBuffer(rawFilters, buf, key);
        }
        virtual SWModule & AddOptionFilter(SWFilter * newfilter) {
                optionFilters->push_back(newfilter);
                return *this;
        }
        virtual void optionFilter(SWBuf &buf, SWKey *key) {
                filterBuffer(optionFilters, buf, key);
        }
        virtual const char *StripText(char *buf = 0, int len = -1);
        virtual const char *RenderText(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 -----------------------------------------------------------------
        
        SWMODULE_OPERATORS

};

SWORD_NAMESPACE_END
#endif

---