bind.h

// **************************************************************************
// * This file is part of the FreeFileSync project. It is distributed under *
// * GNU General Public License: http://www.gnu.org/licenses/gpl.html       *
// * Copyright (C) Zenju (zenju AT gmx DOT de) - All Rights Reserved        *
// **************************************************************************

#ifndef ZEN_XML_BIND_HEADER_9081740816593478258435
#define ZEN_XML_BIND_HEADER_9081740816593478258435

#include <set>
#include "cvrt_struc.h"
#include "parser.h"
#include "io.h"

namespace zen
{

template <class String> inline
XmlDoc load(const String& filename) //throw XmlFileError, XmlParsingError
{
    std::string stream = loadStream(filename); //throw XmlFileError
    return parse(stream); //throw XmlParsingError
}



template <class String> inline
void save(const XmlDoc& doc,
          const String& filename,
          const std::string& lineBreak = "\r\n",
          const std::string& indent = "    ") //throw XmlFileError
{
    std::string stream = serialize(doc, lineBreak, indent); //throw ()
    saveStream(stream, filename); //throw XmlFileError
}


class XmlOut
{
public:

    XmlOut(XmlDoc& doc) : ref_(&doc.root()) {}

    XmlOut(XmlElement& element) : ref_(&element) {}


    template <class String>
    XmlOut operator[](const String& name) const
    {
        const std::string utf8name = utfCvrtTo<std::string>(name);
        XmlElement* child = ref_->getChild(utf8name);
        return child ? *child : ref_->addChild(utf8name);
    }


    template <class T>
    void operator()(const T& value) { writeStruc(value, *ref_); }


    template <class String, class T>
    void attribute(const String& name, const T& value) { ref_->setAttribute(name, value); }

    XmlElement& ref() { return *ref_; }

private:
    XmlElement* ref_; //always bound!
};


class XmlIn
{
    class ErrorLog;
    struct ConversionToBool { int dummy; };

public:

    XmlIn(const XmlDoc& doc) : refIndex(0), log(std::make_shared<ErrorLog>()) { refList.push_back(&doc.root()); }

    XmlIn(const XmlElement* element) : refIndex(0), log(std::make_shared<ErrorLog>()) { refList.push_back(element); }

    XmlIn(const XmlElement& element) : refIndex(0), log(std::make_shared<ErrorLog>()) { refList.push_back(&element); }


    template <class String>
    XmlIn operator[](const String& name) const
    {
        std::vector<const XmlElement*> childList;

        if (refIndex < refList.size())
        {
            auto iterPair = refList[refIndex]->getChildren(name);
            std::for_each(iterPair.first, iterPair.second,
            [&](const XmlElement& child) { childList.push_back(&child); });
        }

        return XmlIn(childList, childList.empty() ? getChildNameFormatted(name) : std::string(), log);
    }


    void next() { ++refIndex; }


    template <class T>
    bool operator()(T& value) const
    {
        if (refIndex < refList.size())
        {
            bool success = readStruc(*refList[refIndex], value);
            if (!success)
                log->notifyConversionError(getNameFormatted());
            return success;
        }
        else
        {
            log->notifyMissingElement(getNameFormatted());
            return false;
        }
    }


    template <class String, class T>
    bool attribute(const String& name, T& value) const
    {
        if (refIndex < refList.size())
        {
            bool success = refList[refIndex]->getAttribute(name, value);
            if (!success)
                log->notifyMissingAttribute(getNameFormatted(), utfCvrtTo<std::string>(name));
            return success;
        }
        else
        {
            log->notifyMissingElement(getNameFormatted());
            return false;
        }
    }

    const XmlElement* get() const { return refIndex < refList.size() ? refList[refIndex] : nullptr; }


    operator int ConversionToBool::* () const { return get() ? &ConversionToBool::dummy : nullptr; }


    bool errorsOccured() const { return !log->elementList().empty(); }


    template <class String>
    std::vector<String> getErrorsAs() const
    {
        std::vector<String> output;
        const auto& elements = log->elementList();
        std::transform(elements.begin(), elements.end(), std::back_inserter(output), [](const std::string& str) { return utfCvrtTo<String>(str); });
        return output;
    }

private:
    XmlIn(const std::vector<const XmlElement*>& siblingList, const std::string& elementNameFmt, const std::shared_ptr<ErrorLog>& sharedlog) :
        refList(siblingList), refIndex(0), formattedName(elementNameFmt), log(sharedlog)
    { assert((!siblingList.empty() && elementNameFmt.empty()) || (siblingList.empty() && !elementNameFmt.empty())); }

    static std::string getNameFormatted(const XmlElement& elem) //"<Root> <Level1> <Level2>"
    {
        return (elem.parent() ? getNameFormatted(*elem.parent()) + " " : std::string()) + "<" + elem.getNameAs<std::string>() + ">";
    }

    std::string getNameFormatted() const
    {
        if (refIndex < refList.size())
        {
            assert(formattedName.empty());
            return getNameFormatted(*refList[refIndex]);
        }
        else
            return formattedName;
    }

    std::string getChildNameFormatted(const std::string& childName) const
    {
        std::string parentName = getNameFormatted();
        return (parentName.empty() ? std::string() : (parentName + " ")) + "<" + childName + ">";
    }

    class ErrorLog
    {
    public:
        void notifyConversionError (const std::string& formattedName)  { insert(formattedName); }
        void notifyMissingElement  (const std::string& formattedName)  { insert(formattedName); }
        void notifyMissingAttribute(const std::string& formattedName, const std::string& attribName) { insert(formattedName + " @" + attribName); }

        const std::vector<std::string>& elementList() const { return failedElements; }

    private:
        void insert(const std::string& newVal)
        {
            if (usedElements.insert(newVal).second)
                failedElements.push_back(newVal);
        }

        std::vector<std::string> failedElements; //unique list of failed elements
        std::set<std::string>    usedElements;
    };

    std::vector<const XmlElement*> refList; //all sibling elements with same name (all pointers bound!)
    size_t refIndex;                        //this sibling's index in refList
    std::string formattedName;     //contains full and formatted element name if (and only if) refList is empty
    std::shared_ptr<ErrorLog> log; //always bound
};
}

#endif //ZEN_XML_BIND_HEADER_9081740816593478258435