/home/rixxx/src/xmlminus/src/xmlminus.h

#ifndef _XMLMINUS_H_
#define _XMLMINUS_H_

#include <iostream>
#include <string>
#include <locale>
#include <stdexcept>
#include <sstream>
#include <vector>
#include <map>
#include <boost/lexical_cast.hpp>

namespace
{
const char *ENTITIES[][2] = {{"&amp;", "&"}, {"&lt;", "<"}, {"&gt;", ">"}, {"&quot;", "\""}, {"&apos;", "\'"}, {0, 0}};
}

namespace xmlm
{

class ParseError : public std::runtime_error
{
    public: ParseError(const std::string &what) : std::runtime_error(what) {}
};


template <class T>
class BasicElement
{
public:
    typedef T string_type;
    typedef typename string_type::value_type char_type;
    typedef typename string_type::traits_type traits_type;
    typedef typename string_type::allocator_type allocator_type;
    typedef std::basic_istream<char_type, traits_type> istream_type;
    typedef std::basic_ostream<char_type, traits_type> ostream_type;
    typedef std::vector<BasicElement<T> > ChildVector;
    typedef std::map<string_type, string_type> AttributeMap;
    typedef enum { NORMAL, COMMENT, DECLARATION, TERMINATOR } ElementType;
    

    BasicElement(istream_type &in) : locale(in.getloc()) { parse(in); }
    

    BasicElement(istream_type &in, const std::locale &loc) : locale(loc) { std::locale old = in.imbue(locale); parse(in); in.imbue(old); }
    

    BasicElement(const string_type &value = "", ElementType type = NORMAL) : value(value), type(type) {}
    

    BasicElement(const string_type &value, const std::locale &loc, ElementType type = NORMAL) : locale(loc), value(value), type(type) {}
    

    BasicElement(const std::locale &loc, ElementType type = NORMAL) : locale(loc), type(type) {}
    

    std::locale &getLocale() { return locale; }
    

    const std::locale &getLocale() const { return locale; }
    

    void setLocale(const std::locale &loc) { locale = loc; }
    

    const string_type &getValue() const { return value; }
    

    string_type &getValue() { return value; }
    

    void setValue(const string_type &val) { value = val; }
    

    const ChildVector &getChildren() const { return children; }
    

    ChildVector &getChildren() { return children; }
    

    const AttributeMap &getAttributes() const { return attributes; }
    

    AttributeMap &getAttributes() { return attributes; }
    

    const string_type &getText() const { return text; }

    string_type &getText() { return text; }

    void setText(const string_type &str) { text = str; }
    

    ElementType getType() const { return type; }
    

    void setType(ElementType t) { type = t; }
    

    template<typename valueT>
    void setAttribute(const string_type &key, const valueT &val);
    

    template<typename valueT>
    valueT getAttribute(const string_type &key) const;
    

    const string_type &getAttributeRaw(const string_type &key) const
    {
        typename AttributeMap::const_iterator i(attributes.find(key));
        if(i == attributes.end()) throw ParseError("attribute not found");
        return i->second;
    }
    

    string_type &getAttributeRaw(const string_type &key)
    {
        typename AttributeMap::iterator i(attributes.find(key));
        if(i == attributes.end()) throw ParseError("attribute not found");
        return i->second;
    }
    

    void setAttributeRaw(const string_type &key, const string_type &val) { attributes[key] = val; }
    

    bool hasAttribute(const string_type &key) const { return (attributes.find(key) != attributes.end()); }
    

    void print(ostream_type &out, int indent = 0) const;
    

    void parse(istream_type &in);
    

    const BasicElement<T> &getChild(const string_type &val) const
    {
        typename ChildVector::const_iterator i = std::find_if(children.begin(), children.end(), valuecmp(val));
        if(i == children.end()) throw ParseError("can't find child");
        return *i;
    }


    BasicElement<T> &getChild(const string_type &val)
    {
        typename ChildVector::iterator i = std::find_if(children.begin(), children.end(), valuecmp(val));
        if(i == children.end()) throw ParseError("can't find child");
        return *i;
    }


    static void entityEncode(string_type &str);
    

    static void entityDecode(string_type &str);
    
private:
    std::locale locale;
    string_type value;
    ElementType type;
    
    ChildVector children;
    AttributeMap attributes;
    
    string_type text;
    
    void readString(istream_type &in, string_type &str);
    void readAttribute(istream_type &in);
    void readQuotedString(istream_type &in, string_type &str);
    void readText(istream_type &in);
    void readComment(istream_type &in);
    
    typedef std::map<string_type, string_type> EntityMap;
    static EntityMap entities;
    
    static void buildEntities();
    static void replaceAll(string_type &str, const string_type &from, const string_type& to);
    
    struct valuecmp
    {
        string_type value;
        valuecmp(const string_type &value) : value(value) {}
        bool operator()(const BasicElement<T>& element) { return (element.getValue() == value); }
    };
};

template<class T>
typename BasicElement<T>::EntityMap BasicElement<T>::entities;

template <class T>
template<typename valueT>
void BasicElement<T>::setAttribute(const string_type &key, const valueT &val)
{
    attributes[key] = boost::lexical_cast<string_type>(val);
}

template <class T>
template<typename valueT>
valueT BasicElement<T>::getAttribute(const string_type &key) const
{
    typename AttributeMap::const_iterator i = attributes.find(key);
    if(i == attributes.end()) throw ParseError("attribute not found");
    return boost::lexical_cast<valueT>(i->second);
}

template <class T>
void BasicElement<T>::parse(istream_type &in)
{
    std::ws(in);
    
    if(in.eof()) throw ParseError("unexpected end of file");
    else if(!in.good()) throw std::runtime_error("i/o error");

    if(in.get() != '<') throw ParseError("expected: '<'");

    switch(in.peek())
    {
    case '/':
        type = TERMINATOR;
        in.get();
        break;
    case '!':
        type = COMMENT;
        in.get();
        break;
    case '?':
        type = DECLARATION;
        in.get();
        break;
    default:
        type = NORMAL;
        break;
    };
    
    value.clear();
    
    if(type == COMMENT)
    {
        readComment(in);
        return;
    }
    
    readString(in, value);
    
    while(std::isspace(static_cast<char_type>(in.peek()), locale))
    {
        std::ws(in);
        if(in.eof()) throw ParseError("unexpected end of file");
        else if(!in.good()) throw std::runtime_error("i/o error");
        
        if(std::isalnum(static_cast<char_type>(in.peek()), locale))
        {
            readAttribute(in);
        } else break;
    }
    
    bool single = false;
    if(in.peek() == '/')
    {
        if(type != NORMAL) throw ParseError("unexpected character: '/'");

        in.get();
        std::ws(in);
        if(in.eof()) throw ParseError("unexpected end of file");
        else if(!in.good()) throw std::runtime_error("i/o error");

        single = true;  
    }
    
    if(type == DECLARATION)
    {
        if(in.get() != '?')  throw ParseError("expected: '?'");
        std::ws(in);
    }
    
    if(in.get() != '>') throw ParseError("expected: '>'");
    
    while(!single && type == NORMAL)
    {
        std::ws(in);
        if(in.eof()) throw ParseError("unexpected end of file");
        else if(!in.good()) throw std::runtime_error("i/o error");

        if(in.peek() == '<')
        {
            children.push_back(BasicElement<T>(locale));
            
            BasicElement<T> &child = children.back();
            child.parse(in);
            
            if(child.type == TERMINATOR)
            {
                if(child.value != value) throw ParseError("incorrect terminator");
                children.pop_back();
                break;
            }
        } else
        {
            readText(in);
        }
    }
    
    entityDecode(text);
}

// Read a string of alphanumeric characters or '_', ':', '.' or '-'
template<class T>
void BasicElement<T>::readString(istream_type &in, string_type &str)
{
    while(in.good())
    {
        char_type ch = in.peek();
        
        if(!std::isalnum(ch, locale) && ch != '_' && ch != ':' && ch != '.' && ch != '-') break;
        str.push_back(ch);
        
        in.get();
    }
}

template<class T>
void BasicElement<T>::readAttribute(istream_type &in)
{
    string_type key;    
    readString(in, key);
        
    std::ws(in);
    if(in.eof()) throw ParseError("unexpected end of file");
    else if(!in.good()) throw std::runtime_error("i/o error");

    if(in.get() != '=') throw ParseError("expected: '='");
    std::ws(in);
    if(in.eof()) throw ParseError("unexpected end of file");
    else if(!in.good()) throw std::runtime_error("i/o error");
    
    string_type val;
    readQuotedString(in, val);
    entityDecode(val);
    
    attributes.insert(typename AttributeMap::value_type(key, val));
}

template<class T>
void BasicElement<T>::readQuotedString(istream_type &in, string_type &str)
{
    if(in.get() != '"') throw ParseError("expected: quoted string literal");
    
    char_type ch;
    while((ch = in.get()) != '"' && in.good())
    {
        if(ch == '\n' || ch == '\r' || ch == '\t' || ch == '<' || ch == '>') break;
        
        str.push_back(ch);
    }
    
    if(ch != '"') throw ParseError("unterminated string literal");
}

template<class T>
void BasicElement<T>::readText(istream_type &in)
{
    char_type ch;

    while((ch = in.peek()) != '<' && in.good())
    {
        if(std::isspace(ch, locale))
        {
            text.push_back(' ');
            std::ws(in);
        } else
        {
            text.push_back(ch);
            in.get();
        }
    }
    
    if(in.eof()) throw ParseError("unexpected end of file");
    else if(!in.good()) throw std::runtime_error("i/o error");

    if(ch != '<') throw std::logic_error("expected: '<'");
}

template <class T>
void BasicElement<T>::readComment(istream_type &in)
{
    int depth = 1;
    char_type ch = 0;
    while(depth > 0 && in.good())
    {
        ch = in.get();
        if(!(depth == 1 && ch == '>')) value.push_back(ch);
        if(ch == '<') ++depth;
        else if(ch == '>') --depth;
    }
    
    if(in.eof()) throw ParseError("unexpected end of file");
    else if(!in.good()) throw std::runtime_error("i/o error");
    
    if(ch != '>') throw std::logic_error("expected: '>'");
}

template <class T>
void BasicElement<T>::print(ostream_type &out, int indent) const
{
    for(int i = 0; i < indent; ++i) out << '\t';
    
    out << '<';
    
    if(type == COMMENT) out << '!';
    else if(type == DECLARATION) out << '?';
    
    out << value;
    
    for(typename AttributeMap::const_iterator i(attributes.begin()); i != attributes.end(); ++i)
    {
        out << ' ' << (i->first) << "=\"";
        string_type value(i->second);
        entityEncode(value);
        out << value << '"';
    }
    
    if(text.size() == 0 && children.size() == 0 && type == NORMAL)
    {
        out << '/' << '>' << '\n';
        return;
    }
    
    if(type == DECLARATION) out << '?';
    out << '>' << '\n';
    if(type != NORMAL) return;
    
    for(typename ChildVector::const_iterator i(children.begin()); i != children.end(); ++i)
    {
        i->print(out, indent+1);
    }
    
    if(text.size() > 0)
    {
        for(int i = 0; i < (indent+1); ++i) out << '\t';
        string_type temp(text);
        entityEncode(temp);
        out << temp;
        out << '\n';
    }
    
    for(int i = 0; i < indent; ++i) out << '\t';
    out << '<' << '/' << value << '>' << '\n';
}

template<class T>
std::basic_ostream<typename T::value_type, typename T::traits_type> &operator<<(std::basic_ostream<typename T::value_type, typename T::traits_type> &out, const BasicElement<T> &element)
{
    std::locale old = out.imbue(element.getLocale());
    element.print(out);
    out.imbue(old);
    return out;
}

template<class T>
std::basic_istream<typename T::value_type, typename T::traits_type> &operator>>(std::basic_istream<typename T::value_type, typename T::traits_type> &in, BasicElement<T> &element)
{
    std::locale old = in.imbue(element.getLocale());
    element.parse(in);
    in.imbue(old);
    return in;
}

template<class T>
        void BasicElement<T>::buildEntities()
{
    entities.clear();
    
    int n = 0;
    while(ENTITIES[n][0])
    {
        string_type key;
        string_type val;
        for(const char *c = ENTITIES[n][0]; *c; ++c) key.push_back(*c);
        for(const char *c = ENTITIES[n][1]; *c; ++c) val.push_back(*c);
        
        entities[key] = val;
        ++n;
    }
}

template<class T>
        void BasicElement<T>::replaceAll(string_type &str, const string_type &from, const string_type& to)
{
    typename string_type::size_type pos = 0;
    while((pos = str.find(from, pos)) != string_type::npos)
    {
        str.replace(pos, from.size(), to);
        ++pos;
    }
}

template<class T>
void BasicElement<T>::entityEncode(string_type &str)
{
    if(entities.empty()) buildEntities();
    
    for(typename EntityMap::iterator i(entities.begin()); i != entities.end(); ++i)
    {
        replaceAll(str, i->second, i->first);
    }
}

template<class T>
void BasicElement<T>::entityDecode(string_type &str)
{
    if(entities.empty()) buildEntities();
    
    for(typename EntityMap::iterator i(entities.begin()); i != entities.end(); ++i)
    {
        replaceAll(str, i->first, i->second);
    }
}


template <class T>
class BasicDocument
{
public:
    typedef T string_type;
    typedef typename T::value_type char_type;
    typedef typename T::traits_type traits_type;
    typedef std::basic_istream<char_type, traits_type> istream_type;
    typedef std::basic_ostream<char_type, traits_type> ostream_type;
    typedef std::vector<BasicElement<T> > ChildVector;
    

    BasicDocument(istream_type &in) : locale(in.getloc()) { parse(in); }
    

    BasicDocument(istream_type &in, const std::locale &loc) : locale(loc) { std::locale old = in.imbue(locale); parse(in); in.imbue(old); }
    

    BasicDocument(const std::string &filename)
    {
        std::basic_ifstream<char_type, traits_type> in(filename);
        locale = in.getloc();
        parse(in);
    }
    

    BasicDocument(const std::string &filename, const std::locale &loc)
        : locale(loc)
    {
        std::basic_ifstream<char_type, traits_type> in(filename);
        in.imbue(locale);
        parse(in);
    }


    BasicDocument(const std::locale &locale)
        : locale(locale)
    {
        children.push_back(BasicElement<T>(locale));
        check();
    }
    
    BasicDocument()
    {
        children.push_back(BasicElement<T>(locale));
        check();
    }
    

    std::locale &getLocale() { return locale; }
    

    const std::locale &getLocale() const { return locale; }
    

    BasicElement<T> &getRootElement() { if(!rootElement) throw ParseError("no root element found"); return *rootElement; }
    

    const BasicElement<T> &getRootElement() const { if(!rootElement) throw ParseError("no root element found"); return *rootElement; }


    const ChildVector &getChildren() const { return children; }
    

    ChildVector &getChildren() { return children; }
    

    void parse(istream_type &in);
    

    void print(ostream_type &out) const;
    
private:
    std::locale locale;
    ChildVector children;
    
    BasicElement<T> *rootElement;

    void check();
};

template <class T>
void BasicDocument<T>::parse(istream_type &in)
{
    if(!children.empty()) children.clear();
    
    while(in.good())
    {
        children.push_back(BasicElement<T>(locale));
        children.back().parse(in);
        if(in.good()) std::ws(in);
    }
    
    if(!in.eof()) throw std::runtime_error("i/o error");
    
    check();
}

template <class T>
void BasicDocument<T>::check()
{
    rootElement = NULL;
    for(typename ChildVector::iterator i(children.begin()); i != children.end(); ++i)
    {
        if(i->getType() == BasicElement<T>::TERMINATOR) throw ParseError("tag - end tag mismatch");
        if(i->getType() != BasicElement<T>::NORMAL) continue;
        
        if(rootElement) throw ParseError("multiple root elements");
        rootElement = &(*i);
    }
    
    if(!rootElement) throw ParseError("no root element found");
}

template <class T>
void BasicDocument<T>::print(ostream_type &out) const
{
    for(typename ChildVector::const_iterator i(children.begin()); i != children.end(); ++i)
    {
        i->print(out);
    }
}

template<class T>
std::basic_ostream<typename T::value_type, typename T::traits_type> &operator<<(std::basic_ostream<typename T::value_type, typename T::traits_type> &out, const BasicDocument<T> &document)
{
    std::locale old = out.imbue(document.getLocale());
    document.print(out);
    out.imbue(old);
    return out;
}

template<class T>
std::basic_istream<typename T::value_type, typename T::traits_type> &operator>>(std::basic_istream<typename T::value_type, typename T::traits_type> &in, BasicDocument<T> &document)
{
    std::locale old = in.imbue(document.getLocale());
    document.parse(in);
    in.imbue(old);
    return in;
}

typedef BasicElement<std::string> Element;
typedef BasicDocument<std::string> Document;

#ifdef HAVE_WSTRING
typedef BasicElement<std::wstring> wElement;
typedef BasicDocument<std::wstring> wDocument;
#endif

}

#endif

---