---

CTBxmlIStream.hxx

Go to the documentation of this file.

#ifndef _CTBxmlIStream_HXX
#define _CTBxmlIStream_HXX 1

/*----------------------------------------------------------------------------*/
/* C Tool Box: Designed and implemented by:                                   */
/*    Walter F.J. Mueller   Gesellschaft fuer Schwerionenforschung (GSI)      */
/*                          Planckstrasse 1, D-64291 Darmstadt, Germany       */
/*                  Email:  W.F.J.Mueller@gsi.de                              */
/*                  WWW:    http://www-kp3.gsi.de/www/kp3/people/mueller.html */
/*----------------------------------------------------------------------------*/

#include <strstream.h>

#include "CTBgrab.hxx"
#include "CTBpair.hxx"
#include "CTBstring.hxx"
#include "CTBtime.hxx"
#include "CTBvector.hxx"
#include "CTBxmlLexer.hxx"

class CTBxmlToken {

  friend class CTBxmlIStream;

  public:
    enum type { invalid = -1,               
                fail,                       
                eof,                        
                data,                       
                starttag,                   
                endtag,                     
                emptytag,                   
                comment,                    
                xml,                        
                pi                          
    };

    explicit        CTBxmlToken(int i_type = CTBxmlToken::invalid);
                    CTBxmlToken(const CTBxmlToken& rhs);
                    CTBxmlToken(CTBxmlToken& rhs, bool b_grab);
                    ~CTBxmlToken();

    int             Type() const;
    const CTBstring& Text() const;
    const CTBstring& Name() const;
    const CTBstring& Value() const;

    CTBint          NAttribute() const;
    const CTBstring& AttributeName(CTBint i_ind) const;
    const CTBstring& AttributeValue(CTBint i_ind) const;

    void            Clear();
    void            Grab(CTBxmlToken& rhs);

    void            ToStream(ostream& os) const;

    void            Dump(int i_indent=0, ostream& os=cout,
                         const char* p_text=0) const;

    bool            operator!() const;
                    operator void* () const;

    CTBxmlToken&    operator=(const CTBxmlToken& rhs);

  private:

    typedef CTBpair<CTBstring,CTBstring> pair_ss_t;
  
    int             mi_type;                
    CTBstring       m_text;                 
    CTBstring       m_name;                 
    CTBstring       m_value;                
    CTBvector<pair_ss_t> m_attribute;       
};

ostream& operator<<(ostream& os, const CTBxmlToken& obj);

class CTBgrab<CTBxmlToken> : public CTBgrabable<CTBxmlToken> {};

//##############################################################################

class CTBxmlOpen;
class CTBxmlClose;

class CTBxmlIStream {
  public:
                    CTBxmlIStream();
    explicit        CTBxmlIStream(istream* p_is);
    explicit        CTBxmlIStream(const char* c_filename, int i_mode=ios::in,
                                  int i_prot=0664);

    virtual         ~CTBxmlIStream();

    void            Attach(istream* p_is);
    void            Open(const char* c_filename, int i_mode=ios::in,
                         int i_prot=0664);
    void            Close();

    bool            Good() const;
    bool            Bad() const;
    bool            Fail() const;
    bool            Eof() const;
    bool            Eod() const;

    void            TrimWhite(bool b_trim);
    void            DropWhite(bool b_drop);

    bool            TrimWhite() const;
    bool            DropWhite() const;

    void            Get(CTBxmlToken& token);
    void            GetTagOrData(CTBxmlToken& token);
    void            GetTagOrNonWhiteData(CTBxmlToken& token);

    void            Unget(CTBxmlToken& token);

    const CTBxmlToken& Peek();
    const CTBxmlToken& PeekTagOrData();
    const CTBxmlToken& PeekTagOrNonWhiteData();

    bool            NextNotEnd();

    bool            CheckElement(const char* c_name);

    void            GetTaggedValue(const char* c_name, int& i_value);
    void            GetTaggedValue(const char* c_name, float& f_value);
    void            GetTaggedValue(const char* c_name, double& d_value);
    void            GetTaggedValue(const char* c_name, CTBstring& value);
    void            GetTaggedValue(const char* c_name, CTBtime& value);

    void            OpenElement(const char* c_name = 0);
    void            CloseElement();
    void            DropElement();

    istream*        GetDataStream();

    void            ToStream(ostream& os) const;

    void            Dump(int i_indent=0, ostream& os=cout,
                         const char* p_text=0) const;

    bool            operator!() const;

                    operator void* () const;

    CTBxmlIStream&  operator>>(CTBxmlToken& token);

    CTBxmlIStream&  operator>>(const CTBxmlOpen& manip);
    CTBxmlIStream&  operator>>(const CTBxmlClose& manip);

  private:
    void            GetDataFromLexer(CTBxmlToken& token);
    void            GetTagFromLexer(CTBxmlToken& token);

    void            SetFail(const char* c_message);

    const CTBxmlToken& FailToken() const;

    CTBstring       ConvertCharRef(const CTBstring& cref);
    CTBstring       ConvertEntityRef(const CTBstring& eref);

    int             GetLexerToken(int i_lexmode, CTBxmlToken& token);

  private:
    istream*        mp_is;                  
    bool            mb_attached;            
    bool            mb_trimwhite;           
    bool            mb_dropwhite;           
    bool            mb_fail;                
    bool            mb_bad;                 
    bool            mb_eof;                 
    istrstream*     mp_iss;                 
    CTBstring       m_data;                 
    CTBvector<CTBstring>  m_tagstack;       
    CTBint          mi_taglevel;            
    CTBxmlToken     m_untoken;              
    CTBxmlToken     m_token;                
    CTBxmlLexer     m_lex;                  
    CTBxmlLexerToken m_lextoken;            
};

template <class T>
CTBxmlIStream& operator>>(CTBxmlIStream& xis, T& obj);

ostream& operator<<(ostream& os, const CTBxmlIStream& obj);

//##############################################################################

class CTBxmlOpen {
  public:
    explicit        CTBxmlOpen(const char* c_name = 0);
    const char*     Name() const;
  private:
    const char*     mc_name;
};

class CTBxmlClose {
  public:
    explicit        CTBxmlClose();
  private:
};

#include "CTBxmlIStream.icc"

#endif

---