CRNXml.cpp

Go to the documentation of this file.

/* Copyright 2012-2016 CoReNum, INSA-Lyon
 * 
 * This file is part of libcrn.
 * 
 * libcrn is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * libcrn 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 Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with libcrn.  If not, see <http://www.gnu.org/licenses/>.
 * 
 * file: CRNXml.cpp
 * \author Yann LEYDIER
 */

#include <CRNUtils/CRNCharsetConverter.h>
#include <CRNXml/CRNXml.h>
#include <3rdParty/tixml2/tinyxml2.h>
#include <CRNException.h>
#include <CRNi18n.h>

using namespace crn;
using namespace xml;

static void xmlerror(int err, const char *str1, const char *str2)
{
    StringUTF8 msg;
    if (str1)
    {
        msg += "\n";
        msg += str1;
    }
    if (str2)
    {
        msg += "\n";
        msg += str2;
    }
    switch (err)
    {
        //case tinyxml2::XML_NO_ERROR:
        case tinyxml2::XML_SUCCESS:
            return;
        case tinyxml2::XML_NO_ATTRIBUTE:
            throw ExceptionNotFound(_("Cannot find attribute.") + msg);
        case tinyxml2::XML_WRONG_ATTRIBUTE_TYPE:
            throw ExceptionDomain(_("Wrong attribute type.") + msg);
        case tinyxml2::XML_ERROR_FILE_NOT_FOUND:
            throw ExceptionNotFound(_("File not found.") + msg);
        case tinyxml2::XML_ERROR_FILE_COULD_NOT_BE_OPENED:
            throw ExceptionIO(_("File could not be opened.") + msg);
        case tinyxml2::XML_ERROR_FILE_READ_ERROR:
            throw ExceptionRuntime(_("File read error.") + msg);
        case tinyxml2::XML_ERROR_ELEMENT_MISMATCH:
        case tinyxml2::XML_ERROR_MISMATCHED_ELEMENT:
            throw ExceptionRuntime(_("Element mismatch.") + msg);
        case tinyxml2::XML_ERROR_PARSING_ELEMENT:
            throw ExceptionRuntime(_("Could not parse element.") + msg);
        case tinyxml2::XML_ERROR_PARSING_ATTRIBUTE:
            throw ExceptionRuntime(_("Could not parse attribute.") + msg);
        case tinyxml2::XML_ERROR_IDENTIFYING_TAG:
            throw ExceptionRuntime(_("Could not identify tag.") + msg);
        case tinyxml2::XML_ERROR_PARSING_TEXT:
            throw ExceptionRuntime(_("Could not parse text.") + msg);
        case tinyxml2::XML_ERROR_PARSING_CDATA:
            throw ExceptionRuntime(_("Could not parse CDATA.") + msg);
        case tinyxml2::XML_ERROR_PARSING_COMMENT:
            throw ExceptionRuntime(_("Could not parse comment.") + msg);
        case tinyxml2::XML_ERROR_PARSING_DECLARATION:
            throw ExceptionRuntime(_("Could not parse declaration.") + msg);
        case tinyxml2::XML_ERROR_PARSING_UNKNOWN:
            throw ExceptionRuntime(_("Could not parse unknown item.") + msg);
        case tinyxml2::XML_ERROR_EMPTY_DOCUMENT:
            throw ExceptionRuntime(_("Empty document.") + msg);
        case tinyxml2::XML_ERROR_PARSING:
            throw ExceptionRuntime(_("Parse error.") + msg);
        case tinyxml2::XML_CAN_NOT_CONVERT_TEXT:
            throw ExceptionRuntime(_("Cannot convert text.") + msg);
        case tinyxml2::XML_NO_TEXT_NODE:
            throw ExceptionNotFound(_("No text node.") + msg);
    }
}

// Node

Node::Node(tinyxml2::XMLNode *n, const SCharsetConverter &c):
    conv(c),
    node(n)
{ }

bool Node::IsElement()
{
    if (!node)
        return false;
    return node->ToElement() != nullptr;
}

bool Node::IsComment()
{
    if (!node)
        return false;
    return node->ToComment() != nullptr;
}

bool Node::IsText()
{
    if (!node)
        return false;
    return node->ToText() != nullptr;
}

Element Node::AsElement()
{
    if (!node)
        throw ExceptionDomain(_("Not an element."));
    tinyxml2::XMLElement *el = node->ToElement();
    if (!el)
        throw ExceptionDomain(_("Not an element."));
    return Element(el, conv);
}

Comment Node::AsComment()
{
    if (!node)
        throw ExceptionDomain(_("Not a comment."));
    tinyxml2::XMLComment *c = node->ToComment();
    if (!c)
        throw ExceptionDomain(_("Not a comment."));
    return Comment(c, conv);
}

Text Node::AsText()
{
    if (!node)
        throw ExceptionDomain(_("Not a text."));
    tinyxml2::XMLText *t = node->ToText();
    if (!t)
        throw ExceptionDomain(_("Not a text."));
    return Text(t, conv);
}

StringUTF8 Node::GetValue() const
{
    return conv->ToUTF8(node->Value());
}

void Node::SetValue(const StringUTF8 &s)
{
    node->SetValue(conv->FromUTF8(s).c_str());
}

Node Node::GetParent()
{
    tinyxml2::XMLNode *par = const_cast<tinyxml2::XMLNode*>(node->Parent());
    return Node(par, conv);
}

Node Node::GetPreviousSibling()
{
    return Node(node->PreviousSibling(), conv);
}

Node Node::GetNextSibling()
{
    return Node(node->NextSibling(), conv);
}

Node& Node::operator++()
{
    *this = GetNextSibling();
    return *this;
}

Node Node::operator++(int)
{
    Node bak(*this);
    *this = GetNextSibling();
    return bak;
}

Element Node::GetPreviousSiblingElement(const StringUTF8 &name)
{
    return Element(node->PreviousSiblingElement(name.IsEmpty() ? nullptr : conv->FromUTF8(name).c_str()), conv);
}

Element Node::GetNextSiblingElement(const StringUTF8 &name)
{
    return Element(node->NextSiblingElement(name.IsEmpty() ? nullptr : conv->FromUTF8(name).c_str()), conv);
}

// Element

Element::Element(tinyxml2::XMLElement *el, const SCharsetConverter &c):
    Node(el, c),
    element(el)
{
    count_subnondes();
}

void Element::count_subnondes()
{
    nb_subnodes = 0;
    nb_subelems = 0;
    if (element)
    {
        for (tinyxml2::XMLNode *sn = element->FirstChild(); sn != nullptr; sn = sn->NextSibling())
            nb_subnodes += 1;
        for (tinyxml2::XMLElement *se = element->FirstChildElement(); se != nullptr; se = se->NextSiblingElement())
            nb_subelems += 1;
    }
}

Element& Element::operator++()
{
    *this = GetNextSiblingElement();
    return *this;
}

Element Element::operator++(int)
{
    Element bak(*this);
    ++(*this);
    return bak;
}

Node Element::GetFirstChild()
{
    return Node(element->FirstChild(), conv);
}

Node Element::GetLastChild()
{
    return Node(element->LastChild(), conv);
}

Element Element::GetFirstChildElement(const StringUTF8 &name)
{
    return Element(element->FirstChildElement(name.IsEmpty() ? nullptr : name.CStr()), conv);
}

Element Element::GetLastChildElement(const StringUTF8 &name)
{
    return Element(element->LastChildElement(name.IsEmpty() ? nullptr : name.CStr()), conv);
}

StringUTF8 Element::GetFirstChildText()
{
    Node n(GetFirstChild());
    if (!n)
        throw ExceptionNotFound(StringUTF8("const StringUTF8 Element::GetFirstChildText(): ") + _("No child node."));
    Text t(n.AsText()); // may throw
    return t.GetValue();
}

Element Element::PushBackElement(const StringUTF8 &name)
{
    if (name.IsEmpty())
        throw ExceptionInvalidArgument(_("Empty element name."));
    tinyxml2::XMLElement *el = element->GetDocument()->NewElement(conv->FromUTF8(name).c_str());
    element->InsertEndChild(el);
    nb_subnodes += 1;
    nb_subelems += 1;
    return Element(el, conv);
}

Element Element::PushFrontElement(const StringUTF8 &name)
{
    if (name.IsEmpty())
        throw ExceptionInvalidArgument(_("Empty element name."));
    tinyxml2::XMLElement *el = element->GetDocument()->NewElement(conv->FromUTF8(name).c_str());
    element->InsertFirstChild(el);
    nb_subnodes += 1;
    nb_subelems += 1;
    return Element(el, conv);
}

Element Element::InsertElement(Node &n, const StringUTF8 &name)
{
    if (!n)
        throw ExceptionInvalidArgument(_("Null node."));
    if (name.IsEmpty())
        throw ExceptionInvalidArgument(_("Empty element name."));
    tinyxml2::XMLElement *el = element->GetDocument()->NewElement(conv->FromUTF8(name).c_str());
    if (!element->InsertAfterChild(n.node, el))
    {
        element->GetDocument()->DeleteNode(el);
        throw ExceptionNotFound(_("Node not found."));
    }
    nb_subnodes += 1;
    nb_subelems += 1;
    return Element(el, conv);
}

Comment Element::PushBackComment(const StringUTF8 &text)
{
    tinyxml2::XMLComment *c = element->GetDocument()->NewComment(conv->FromUTF8(text).c_str());
    element->InsertEndChild(c);
    nb_subnodes += 1;
    return Comment(c, conv);
}

Comment Element::PushFrontComment(const StringUTF8 &text)
{
    tinyxml2::XMLComment *c = element->GetDocument()->NewComment(conv->FromUTF8(text).c_str());
    element->InsertFirstChild(c);
    nb_subnodes += 1;
    return Comment(c, conv);
}

Comment Element::InsertComment(Node &n, const StringUTF8 &text)
{
    if (!n)
        throw ExceptionInvalidArgument(_("Null node."));
    tinyxml2::XMLComment *c = element->GetDocument()->NewComment(conv->FromUTF8(text).c_str());
    if (!element->InsertAfterChild(n.node, c))
    {
        element->GetDocument()->DeleteNode(c);
        throw ExceptionNotFound(_("Node not found."));
    }
    nb_subnodes += 1;
    return Comment(c, conv);
}

Text Element::PushBackText(const StringUTF8 &text, bool cdata)
{
    tinyxml2::XMLText *t = element->GetDocument()->NewText(cdata ? text.CStr() : conv->FromUTF8(text).c_str());
    t->SetCData(cdata);
    element->InsertEndChild(t);
    nb_subnodes += 1;
    return Text(t, conv);
}

Text Element::PushFrontText(const StringUTF8 &text, bool cdata)
{
    tinyxml2::XMLText *t = element->GetDocument()->NewText(cdata ? text.CStr() : conv->FromUTF8(text).c_str());
    t->SetCData(cdata);
    element->InsertFirstChild(t);
    nb_subnodes += 1;
    return Text(t, conv);
}

Text Element::InsertText(Node &n, const StringUTF8 &text, bool cdata)
{
    if (!n)
        throw ExceptionInvalidArgument(_("Null node."));
    tinyxml2::XMLText *t = element->GetDocument()->NewText(cdata ? text.CStr() : conv->FromUTF8(text).c_str());
    t->SetCData(cdata);
    if (!element->InsertAfterChild(n.node, t))
    {
        element->GetDocument()->DeleteNode(t);
        throw ExceptionNotFound(_("Node not found."));
    }
    nb_subnodes += 1;
    return Text(t, conv);
}

Node Element::PushBackClone(Node &n, bool recursive)
{
    if (!n)
        throw ExceptionInvalidArgument(_("Null node."));
    // element?
    try
    {
        Element el(n.AsElement());
        Element newel(PushBackElement(el.GetName()));
        for (Element::Attribute a = el.BeginAttribute(); a != el.EndAttribute(); ++a)
            newel.SetAttribute(a.GetName(), a.GetValue<StringUTF8>());
        if (recursive)
        {
            for (Node sn = el.BeginNode(); sn != el.EndNode(); ++sn)
                newel.PushBackClone(sn, recursive);
        }
        return newel;
    }
    catch (ExceptionDomain &) { }
    // comment?
    try
    {
        Comment c(n.AsComment());
        return PushBackComment(c.GetValue());
    }
    catch (ExceptionDomain &) { }
    // text?
    try
    {
        Text t(n.AsText());
        return PushBackText(t.GetValue(), t.IsCData());
    }
    catch (ExceptionDomain &) { }
    // other
    // - declaration: not possible in an element
    // - unknown
    tinyxml2::XMLUnknown *un = n.node->ToUnknown();
    if (un)
    {
        tinyxml2::XMLUnknown *nun = element->GetDocument()->NewUnknown(un->Value());
        element->InsertEndChild(nun);
        nb_subnodes += 1;
        return Node(nun, conv);
    }
    else
        throw ExceptionInvalidArgument(_("Invalid node."));
}

void Element::Clear()
{
    element->DeleteChildren();
    count_subnondes();
}

void Element::RemoveChild(Node &n)
{
    element->DeleteChild(n.node);
    n.node = nullptr;
    count_subnondes();
}

void Element::SetAttribute(const StringUTF8 &name, const StringUTF8 &value)
{
    if (name.IsEmpty())
        throw ExceptionInvalidArgument(_("Empty attribute name."));
    element->SetAttribute(conv->FromUTF8(name).c_str(), conv->FromUTF8(value).c_str());
}

void Element::RemoveAttribute(const StringUTF8 &name)
{
    if (name.IsEmpty())
        throw ExceptionInvalidArgument(_("Empty attribute name."));
    element->DeleteAttribute(conv->FromUTF8(name).c_str());
}

Element::Attribute Element::BeginAttribute()
{
    return Attribute(const_cast<tinyxml2::XMLAttribute*>(element->FirstAttribute()), conv);
}

Element::Attribute Element::EndAttribute()
{
    return Attribute(nullptr, conv);
}

void Element::queryAttribute(const StringUTF8 &name, StringUTF8 &value) const
{
    if (name.IsEmpty())
        throw ExceptionInvalidArgument(_("Empty attribute name."));
    const char *val = element->Attribute(conv->FromUTF8(name).c_str());
    if (!val)
        throw ExceptionNotFound(_("Cannot find attribute: ") + name);
    value = conv->ToUTF8(val);
}

void Element::queryAttribute(const StringUTF8 &name, int &value) const
{
    if (name.IsEmpty())
        throw ExceptionInvalidArgument(_("Empty attribute name."));
    int res = element->QueryIntAttribute(conv->FromUTF8(name).c_str(), &value);
    xmlerror(res, element->GetDocument()->GetErrorStr1(), element->GetDocument()->GetErrorStr2());
}

void Element::queryAttribute(const StringUTF8 &name, unsigned int &value) const
{
    if (name.IsEmpty())
        throw ExceptionInvalidArgument(_("Empty attribute name."));
    int res = element->QueryUnsignedAttribute(conv->FromUTF8(name).c_str(), &value);
    xmlerror(res, element->GetDocument()->GetErrorStr1(), element->GetDocument()->GetErrorStr2());
}

void Element::queryAttribute(const StringUTF8 &name, bool &value) const
{
    if (name.IsEmpty())
        throw ExceptionInvalidArgument(_("Empty attribute name."));
    int res = element->QueryBoolAttribute(conv->FromUTF8(name).c_str(), &value);
    xmlerror(res, element->GetDocument()->GetErrorStr1(), element->GetDocument()->GetErrorStr2());
}

void Element::queryAttribute(const StringUTF8 &name, double &value) const
{
    if (name.IsEmpty())
        throw ExceptionInvalidArgument(_("Empty attribute name."));
    int res = element->QueryDoubleAttribute(conv->FromUTF8(name).c_str(), &value);
    xmlerror(res, element->GetDocument()->GetErrorStr1(), element->GetDocument()->GetErrorStr2());
}

void Element::queryAttribute(const StringUTF8 &name, float &value) const
{
    if (name.IsEmpty())
        throw ExceptionInvalidArgument(_("Empty attribute name."));
    int res = element->QueryFloatAttribute(conv->FromUTF8(name).c_str(), &value);
    xmlerror(res, element->GetDocument()->GetErrorStr1(), element->GetDocument()->GetErrorStr2());
}

// Attribute

Element::Attribute::Attribute(tinyxml2::XMLAttribute *a, const SCharsetConverter &c):
    attr(a),
    conv(c)
{ }

Element::Attribute& Element::Attribute::operator++()
{
    attr = const_cast<tinyxml2::XMLAttribute*>(attr->Next());
    return *this;
}

Element::Attribute Element::Attribute::operator++(int)
{
    Attribute bak(*this);
    attr = const_cast<tinyxml2::XMLAttribute*>(attr->Next());
    return bak;
}

Element::Attribute Element::Attribute::Next()
{
    return Attribute(const_cast<tinyxml2::XMLAttribute*>(attr->Next()), conv);
}

StringUTF8 Element::Attribute::GetName() const
{
    return conv->ToUTF8(attr->Name());
}

void Element::Attribute::SetValue(const StringUTF8 &value)
{
    attr->SetAttribute(conv->FromUTF8(value).c_str());
}

void Element::Attribute::queryValue(StringUTF8 &value) const
{
    const char *val = attr->Value();
    value = conv->ToUTF8(val);
}

void Element::Attribute::queryValue(int &value) const
{
    int res = attr->QueryIntValue(&value);
    xmlerror(res, nullptr, nullptr);
}

void Element::Attribute::queryValue(unsigned int &value) const
{
    int res = attr->QueryUnsignedValue(&value);
    xmlerror(res, nullptr, nullptr);
}

void Element::Attribute::queryValue(bool &value) const
{
    int res = attr->QueryBoolValue(&value);
    xmlerror(res, nullptr, nullptr);
}

void Element::Attribute::queryValue(double &value) const
{
    int res = attr->QueryDoubleValue(&value);
    xmlerror(res, nullptr, nullptr);
}

void Element::Attribute::queryValue(float &value) const
{
    int res = attr->QueryFloatValue(&value);
    xmlerror(res, nullptr, nullptr);
}

// Comment

Comment::Comment(tinyxml2::XMLComment *c, const SCharsetConverter &co):
    Node(c, co),
    comment(c)
{ }

// Text

Text::Text(tinyxml2::XMLText *t, const SCharsetConverter &c):
    Node(t, c),
    text(t)
{ }

bool Text::IsCData() const
{
    return text->CData();
}

StringUTF8 Text::GetValue() const
{
    if (text->CData())
        return text->Value();
    else
        return conv->ToUTF8(text->Value());
}

// Document

Document::Document(const StringUTF8 &encoding, const StringUTF8 &version, bool char_conversion_throws):
    doc(std::make_unique<tinyxml2::XMLDocument>()),
    enc(encoding),
    ver(version),
    conv(std::make_shared<CharsetConverter>(encoding.Std(), true, char_conversion_throws))
{
    StringUTF8 decl = "xml version=\"" + version + "\" encoding=\"" + encoding + "\"";
    doc->InsertEndChild(doc->NewDeclaration(conv->FromUTF8(decl).c_str()));
}

Document::Document(const Path &fname, bool char_conversion_throws):
    doc(std::make_unique<tinyxml2::XMLDocument>()),
    filename(fname)
{
    int res = doc->LoadFile(fname.CStr());
    if (res)
    {
        crn::StringUTF8 s1, s2;
        if (doc->GetErrorStr1())
            s1 = doc->GetErrorStr1();
        if (doc->GetErrorStr2())
            s2 = doc->GetErrorStr2();
        doc.reset();
        xmlerror(res, s1.IsEmpty() ? nullptr : s1.CStr(), s2.IsEmpty() ? nullptr : s2.CStr());
    }
    tinyxml2::XMLNode *node = doc->FirstChild();
    while (node)
    {
        tinyxml2::XMLDeclaration *decl = node->ToDeclaration();
        if (decl)
        {
            StringUTF8 val = decl->Value();
            StringUTF8 ekey = "encoding=";
            size_t beg = val.Find(ekey);
            if (beg == StringUTF8::NPos())
                enc = "UTF-8";
            else
            {
                beg += ekey.Size();
                char sep = val[beg];
                beg += 1;
                size_t en = val.Find(sep, beg);
                if (en == StringUTF8::NPos())
                    enc = "UTF-8";
                else
                    enc = val.SubString(beg, en - beg);
            }
            StringUTF8 vkey = "version=";
            beg = val.Find(vkey);
            if (beg == StringUTF8::NPos())
                ver = "1.0";
            else
            {
                beg += vkey.Size();
                char sep = val[beg];
                beg += 1;
                size_t en = val.Find(sep, beg);
                if (en == StringUTF8::NPos())
                    ver = "1.0";
                else
                    ver = val.SubString(beg, en - beg);
            }
        }
        node = node->NextSibling();
    }
    conv = std::make_shared<CharsetConverter>(enc.Std(), true, char_conversion_throws);
}

Document::Document(const char *content, bool char_conversion_throws):
    doc(std::make_unique<tinyxml2::XMLDocument>()),
    enc("UTF-8"),
    ver("1.0"),
    conv(std::make_shared<CharsetConverter>("UTF-8", true, char_conversion_throws))
{
    int res = doc->Parse(content);
    xmlerror(res, doc->GetErrorStr1(), doc->GetErrorStr2());
}

Document::~Document() = default;

Document::Document(Document&&) = default;
Document& Document::operator=(Document&&) = default;

void Document::Save(const Path &fname)
{
    int res = doc->SaveFile(fname.CStr());
    xmlerror(res, doc->GetErrorStr1(), doc->GetErrorStr2());
    filename = fname;
}

void Document::Save()
{
    if (filename.IsEmpty())
        throw ExceptionUninitialized(_("Empty filename."));
    int res = doc->SaveFile(filename.CStr());
    xmlerror(res, doc->GetErrorStr1(), doc->GetErrorStr2());
}

Element Document::GetRoot()
{
    Element el(BeginElement());
    if (el == EndElement())
        throw ExceptionNotFound(_("No element in the XML."));
    return el;
}

Node Document::GetFirstNode()
{
    return Node(doc->FirstChild(), conv);
}

Node Document::GetLastNode()
{
    return Node(doc->LastChild(), conv);
}

Element Document::GetFirstElement(const StringUTF8 &name)
{
    return Element(doc->FirstChildElement(name.IsEmpty() ? nullptr : conv->FromUTF8(name).c_str()), conv);
}

Element Document::GetLastElement(const StringUTF8 &name)
{
    return Element(doc->LastChildElement(name.IsEmpty() ? nullptr : conv->FromUTF8(name).c_str()), conv);
}

Element Document::PushBackElement(const StringUTF8 &name)
{
    if (name.IsEmpty())
        throw ExceptionInvalidArgument(_("Empty element name."));
    tinyxml2::XMLElement *el = doc->NewElement(conv->FromUTF8(name).c_str());
    doc->InsertEndChild(el);
    return Element(el, conv);
}

Element Document::InsertElement(Node &n, const StringUTF8 &name)
{
    if (!n)
        throw ExceptionInvalidArgument(_("Null node."));
    if (name.IsEmpty())
        throw ExceptionInvalidArgument(_("Empty element name."));
    tinyxml2::XMLElement *el = doc->NewElement(conv->FromUTF8(name).c_str());
    if (!doc->InsertAfterChild(n.node, el))
    {
        doc->GetDocument()->DeleteNode(el);
        throw ExceptionNotFound(_("Node not found."));
    }
    return Element(el, conv);
}

Comment Document::PushBackComment(const StringUTF8 &text)
{
    tinyxml2::XMLComment *c = doc->NewComment(conv->FromUTF8(text).c_str());
    doc->InsertEndChild(c);
    return Comment(c, conv);
}

Comment Document::InsertComment(Node &n, const StringUTF8 &text)
{
    if (!n)
        throw ExceptionInvalidArgument(_("Null node."));
    tinyxml2::XMLComment *c = doc->NewComment(conv->FromUTF8(text).c_str());
    if (!doc->InsertAfterChild(n.node, c))
    {
        doc->GetDocument()->DeleteNode(c);
        throw ExceptionNotFound(_("Node not found."));
    }
    return Comment(c, conv);
}

Node Document::PushBackClone(Node &n, bool recursive)
{
    if (!n)
        throw ExceptionInvalidArgument(_("Null node."));
    // element?
    try
    {
        Element el(n.AsElement());
        Element newel(PushBackElement(el.GetName()));
        for (Element::Attribute a = el.BeginAttribute(); a != el.EndAttribute(); ++a)
            newel.SetAttribute(a.GetName(), a.GetValue<StringUTF8>());
        if (recursive)
        {
            for (Node sn = el.BeginNode(); sn != el.EndNode(); ++sn)
                newel.PushBackClone(sn, recursive);
        }
        return newel;
    }
    catch (ExceptionDomain &) { }
    // comment?
    try
    {
        Comment c(n.AsComment());
        return PushBackComment(c.GetValue());
    }
    catch (ExceptionDomain &) { }
    // text?
    try
    {
        Text t(n.AsText());
        tinyxml2::XMLText *tx = doc->NewText(t.IsCData() ? t.GetValue().CStr() : conv->FromUTF8(t.GetValue()).c_str());
        tx->SetCData(t.IsCData());
        doc->InsertEndChild(tx);
        return Text(tx, conv);
    }
    catch (ExceptionDomain &) { }
    // declaration?
    tinyxml2::XMLDeclaration *de = n.node->ToDeclaration();
    if (de)
    {
        tinyxml2::XMLDeclaration *nde = doc->NewDeclaration(de->Value());
        doc->InsertEndChild(nde);
        return Node(nde, conv);
    }
    // unknown?
    tinyxml2::XMLUnknown *un = n.node->ToUnknown();
    if (un)
    {
        tinyxml2::XMLUnknown *nun = doc->NewUnknown(un->Value());
        doc->InsertEndChild(nun);
        return Node(nun, conv);
    }
    throw ExceptionInvalidArgument(_("Invalid node."));
}

StringUTF8 Document::AsString()
{
    tinyxml2::XMLPrinter pr;
    doc->Print(&pr);
    return pr.CStr();
}