ERAV.h

Go to the documentation of this file.

// ERAV.h           (C) 2010 adolfo@di-mare.com

#ifndef   ERAV_h
#define   ERAV_h   // Aboid multiple inclusion

#include <map>     // these are all the #includes used in the implementation
#include <list>
#include <string>

#include <cctype>  // isalpha() && isdigit() && tolower()
#include <cstdlib> // atoi()
#include <cstring> // memcmp() && size_t

/// [E]ntity [R]elation [A]ttribute [V]alue
namespace ERAV { class WORD; class WORD_tuple; class tuple; class parser; }

#if 0
           "erav2xml( L ==> XML )"     "xml2erav( XML ==> L )"
#endif

// <?xml []...[] ?> <erav> XML </erav>
void erav2xml_enclose( std::string& XML );

// L<tuple> ==> XML ((append))
#define        NOT_const      // L is NOT const: L gets reordered
void erav2xml( NOT_const std::list<ERAV::tuple>& L, std::string& XML );

// L<tuple> ==> XML ((append))
void erav2xml( const std::list<ERAV::WORD_tuple>& L , std::string& XML );

// L<word> ==> W<word> ((append)) || L<string> ==> S<string> ((append))
void erav2xml( const std::list<ERAV::WORD_tuple>& L , ERAV::WORD& W );

// W<word> ==> XML ((append))
void erav2xml( const ERAV::WORD& W , std::string& XML , bool isWORD=true );

// S<string> ==> XML ((append))
inline
void erav2xml( const ERAV::WORD& S , std::string& XML , const std::string& );

// XML ==> [ L<tuple> && W<word> && S<string> ] ((append))
inline void xml2erav(           // throws ERAV::exception on error
    const std::string& XML    ,
    std::list<ERAV::tuple>& L , // append to current value
    ERAV::WORD&             W , // append to current value
    ERAV::WORD&             S   // append to current value
);

// [ L<tuple> && W<word> && S<string> ] ==> XML ((append))
inline void erav2xml(
          std::list<ERAV::tuple>& L , // reordered
    const ERAV::WORD&             W ,
    const ERAV::WORD&             S ,
          std::string& XML            // append to current value
) {
    erav2xml( L , XML );
    erav2xml( W , XML );
    erav2xml( S , XML, std::string() );
//  erav2xml_enclose( XML );
}

inline void erav_clear(
    std::list<ERAV::tuple>& L ,
    ERAV::WORD&             W ,
    ERAV::WORD&             S
);

namespace ERAV {
    // Load L from FROM skippind duplicates.
    void merge_into( std::list<ERAV::tuple>& L, std::list<ERAV::tuple>& FROM );

class tuple { // tuples in the ERAV data base
public:
    int    ID_ENT;       // NOT NULL, -- <K+++> <E> Entity
    struct _rel_ {       //           --        <R> Relation
        short ID;        // NOT NULL, -- <+K++>
        short SUB;       // NOT NULL, -- <++K+>
        char  TYPE;      // NOT NULL,
    } REL;
    int     ATTRIB;      // NOT NULL, -- <+++K>  <A> Attribute
    struct _val_ {       // NOT NULL,            <V> Value
#if 0
        union {
            int    INT;  // (int) or reference into "WORD"
            double FLOAT;
        //  long   TIME; // 2.1474.83.64.7 == 2^31-1
            long   DATE; //   1492-12-31
            long   HOUR; // 12:25:37.000
        };               // 21.47.48.3647  == 2^31-1
#endif
        std::string BLOB;      // binary large object
    } VAL;
//  CONSTRAINT [ERAV_KEY] UNIQUE ( ID_ENT,REL_ID,REL_SUB,ATTRIB )};
};

/// (l<r)==>(-1)   (l==r)==>((0))   (l>r)==>(+1).
int  tplcmp( const ERAV::tuple& l, const ERAV::tuple& r );
/// (l<r) ???.
bool isLess( const ERAV::tuple& l, const ERAV::tuple& r );
// { return ( tplcmp(l,r)<0 ); }
#define USE_isLess
#undef  USE_isLess

/// (l<r) ???.
inline bool operator<( const ERAV::tuple& l, const ERAV::tuple& r ) {
    #ifdef  USE_isLess
        return ( isLess(l,r) );
    #else
        return ( tplcmp(l,r)<0 );
    #endif
}

/// (l==r) ???.
inline bool operator==( const ERAV::tuple& l, const ERAV::tuple& r ) {
    #ifdef  USE_isLess
        return ( !isLess(l,r) && !isLess(r,l) );
    #else
        return ( tplcmp(l,r)==0 );
    #endif
}

const int LANG_LEN=2; // "es" "en" etc...

class WORD_tuple { // referenced by VAL_INT in ERAV_tuple
public:
    int  ID_WORD;
    std::string DESCR;
    char LANG[LANG_LEN];
};

/// \c map<> ( WORD && STRING ).
class WORD { // WORD[25] == [ ("es","Juan"),("en","John"),... ]
    friend void ::erav2xml( const ERAV::WORD& W , std::string& XML , bool );
private:
    typedef std::list< std::pair< std::string , std::string > > DESCR;
    typedef std::map< int , DESCR > MAP;
private:
    MAP m_WORD;
public:
    std::string lookUp( int n , const std::string& lang ) const;
    bool update( int n , const std::string& lang , const std::string& descr );
    void erase( int n );
    void toList( std::list<ERAV::WORD_tuple>& L ) const;
    bool empty() const { return m_WORD.empty(); }
    void clear() { m_WORD.clear(); }
private:
    static DESCR::iterator       lFind(       DESCR& L, const std::string& lang );
    static DESCR::const_iterator lFind( const DESCR& L, const std::string& lang )
    { return lFind( *const_cast<DESCR*>(&L), lang ); }
};

struct attrib { // valid XML attributes for ERAV records
    static const char eREL_TYPE = 'e'; //<entity> && <record>
    enum { ATTRIB=0, FIRST=ATTRIB,
           DESCR,
               ID_ENT, REL_ID,  REL_SUB,   REL_TYPE,
               VAL,    ID_WORD, ID_STRING, LANG,
           LAST=LANG, NONE
};}; // namespace attrib { }

struct tag { // valid XML tags for ERAV records
    enum { attrib=attrib::ATTRIB, first=attrib,
               descr=attrib::DESCR,
               head, erav, entity, record, word, string,
           last=string, none=attrib::NONE
};}; // namespace tag { }

class token {
public: //         "<?"     "?>" "</" "/>"     '..'  ".."
    enum { ZERO=0, LTQ=512, QGT, LTS, SGT,  ID,  STRING }; // token numbers
private:
    friend class parser;
    token() : m_token(0), m_line(), m_lexeme() { }
public:
//  token( char ch ) : m_token(ch), m_lexeme() { m_lexeme = ch; };
    token( int num ) : m_token(num), m_line(), m_lexeme() { };
    void set( int number, const char* yytext, int yyleng, int yyline ) {
        m_token = number; m_lexeme.assign(yytext, yyleng); m_line = yyline;
        setTagAttrib();
    }
    int getTag()    const { return m_tag_attrib; }
    int getAttrib() const { return m_tag_attrib; }
//  operator int()  const { return m_token; } // avoid ambiguity problems
    int num()       const { return m_token; } // return token number
    const std::string & lexeme() const { return m_lexeme; }
    static const char* name(int tk); // token´s name
    bool operator==( int tk ) const { return this->m_token == tk; }
private:
    void setTagAttrib();  // set m_tag_attrib
    int  m_token;         // ZERO, LTQ ... STRING
    int  m_line;
    int  m_tag_attrib;    // record tag && attrib code
    std::string m_lexeme;
};

class context {
    friend class parser;
private:
    context() {}
    ~context() { if (prev!=0) { delete prev; } } // recursive delete all
private:
    context * prev;
    int       REL_ID;
};

// scanner
int yylex( char const** cursor, char const** yytext, int* yyleng, int* yyline );

class parser {
public:
    parser( const char* XML, std::list<ERAV::tuple> & L,
            ERAV::WORD & W, ERAV::WORD & S
    ) : token1(), token2(),
        deleteXML(false),
        m_context(0), m_context_old(0), m_nest_id(0),
        m_str_val()
    { real_set(XML,L,W,S, false); }
    parser( const std::string& XML, std::list<ERAV::tuple> & L,
            ERAV::WORD & W, ERAV::WORD & S
    ) : token1(), token2(),
        deleteXML(false),
        m_context(0), m_context_old(0), m_nest_id(0),
        m_str_val()
    { real_set(XML.c_str(),L,W,S,true); } // makeCopy=true
    void set( const char* XML, std::list<ERAV::tuple> & L,
              ERAV::WORD & W, ERAV::WORD & S )
       { real_set(XML,L,W,S, false); }
    void set( const std::string& XML, std::list<ERAV::tuple> & L,
              ERAV::WORD & W, ERAV::WORD & S )
       { real_set(XML.c_str(), L,W,S,true); }
    ~parser();
    void parse();
private:
    void real_set( const char* XML, std::list<ERAV::tuple> & L,
              ERAV::WORD & W, ERAV::WORD & S, bool makeCopy );
    void match( int num );
    void error( const char* msg ) /* abort(); */;
    friend class exception;
    #define ID_val const std::string & lexeme
        void all();        // all  : head docs;
        void head();       // head : "<?" "xml" args "?>"   | /* empty */;

        void docs();       // docs : doc docs               | /* empty */;
        void doc();        // doc  : '<' ID args nest;
        void nest(ID_val); // nest : "/>" | '>' docs "</" ID '>'

        void args();       // args : arg args               | /* empty */;
        void arg();        // arg  : ID ('=' STRING)?
    #undef ID_val
private:
    void pushContext();   void setAttrib();
    void popContext();    void setAttribVal();
    void emit();
private:
    parser( const parser& ); // forbidden
    void operator= ( const parser& ); // forbidden
private:
    token * m_lookahead;    // flip~flop between token1 && token2
    token   token1, token2; // last && current token

    const char* m_XML;    // yylex() big string input
    bool    deleteXML;    // true when m_XML is a copy
    const char* m_yytext; // scanner fields
    int         m_yyleng;
    int         m_yyline;
    const char* m_cursor;

    context * m_context;     // pushContext() && popContext()
    context * m_context_old; // reuse context structs

    int         m_id;         // current entity id
    int         m_nest_id;    // current rel_id for nested records

    int         m_tag;        // current XML tag being processed
    int         m_attrib;     // which attrib to set with m_str_val
    char        m_rel_type;   // type of m_attrib
    std::string m_str_val;    // attribute value
    int         m_attrib_ref; // reference in attrib argument

    int         m_id_word;   // current word && string id
    bool        m_inWord;    // true <==> <word><descr>
    char        m_lang[4];   // word && string language

    std::list<ERAV::tuple> * m_L; // list<> where ERAV records get appended
    ERAV::WORD * m_WORD;          // WORD  dictionary
    ERAV::WORD * m_STRING;        // STRING dictionary
};

class exception { // thrown from parser::error()
    const char * m_what; // string for last error
    friend void ERAV::parser::error( const char* );
public:
    exception( const char* w ) throw() : m_what(w) { }
//  exception( const exception & o ) : m_what(o.m_what) { }
    const char* what() const throw() { return m_what; }
};

} // namespace ERAV

/// (l == r) ???
inline bool operator==( const ERAV::token& l , int r ) {
    return l.num() == r;
}

#if 0
/// (l == r) ???
inline bool operator==( const ERAV::token& l , const ERAV::token& r ) {
    return ( l.num()== r.num());
}
#endif

/// { L.clear(), W.clear(), S.clear(); }
inline void erav_clear(
    std::list<ERAV::tuple>& L ,
    ERAV::WORD&             W ,
    ERAV::WORD&             S
) {
    L.clear(), W.clear(), S.clear();
}

// XML ==> [ L<tuple> && W<word> && S<string> ] ((append))
inline void xml2erav(           // throws ERAV::exception on error
    const std::string& XML    ,
    std::list<ERAV::tuple>& L , // append to current value
    ERAV::WORD&             W , // append to current value
    ERAV::WORD&             S   // append to current value
) {
    #if 1
        ERAV::parser P( XML , L , W, S );
        P.parse();
    #else
        try {
            ERAV::parser P( XML , L , W, S );
            P.parse();
        }
        catch ( ERAV::exception e ) { /* e.what() describes the error */ }
        catch ( ... ) { /* catch all */ }
    #endif
}

inline
void erav2xml( const ERAV::WORD& S , std::string& XML , const std::string& ) {
     erav2xml( S , XML , false );
}

#undef NOT_const
#endif // ERAV_h

// EOF: ERAV.h