XmlSerializationContext.hpp

//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Commons/Logging.h"
#include "Arp/System/Commons/Exceptions/KeyNotFoundException.hpp"
#include "Arp/System/Commons/Configuration/PlaceholderExpression.hpp"

namespace Arp { namespace System { namespace Commons { namespace Xml
{

using namespace Arp::System::Commons::Configuration;

// forwards
class XmlReader;
class XmlWriter;
class XmlConfigDocument;

// Never, ever use Loggable class here, because XmlSerializationContext is used before logging is initialized
class XmlSerializationContext // : private Loggable<XmlSerializationContext>
{
private: // typedefs
    typedef std::map<String, String>    Attributes;

public: // construction/destruction
    XmlSerializationContext(XmlConfigDocument& document,  Version docSchemaVersion = Version(1, 0));
    XmlSerializationContext(XmlSerializationContext& arg) = default;
    XmlSerializationContext& operator=(XmlSerializationContext& arg) = default;
    ~XmlSerializationContext(void) = default;

public: // operators
    String&         operator[](const String& attributeName);
    const String&   operator[](const String& attributeName)const;

public: // static properties
    static const char* IncludeXmlName;
    static const char* IncludesXmlName;

public: // setter/getter operations
    Version             GetDocumentSchemaVersion(void) const;
    XmlConfigDocument&  GetDocument(void);

public: // operations
    void    ReadDocumentContext(XmlReader& reader);
    void    WriteDocumentContext(XmlWriter& writer)const;
    void    InvalidXmlElementOccurs(XmlReader& reader, const char* xmlElementName);
    void    MissingXmlElementOccurs(XmlReader& reader, const char* xmlElementName);
    void    ReadIncludesElement(XmlReader& reader);
    String  ResolvePath(const char* documentPath);
    String  ResolvePlaceholder(const char* input);
    //ist used by ReadIncludesElement
    void    AddIncludeFile(const String& path);

private: // static methods

private: // methods
    String  ResolveRelativePath(const String& path);
    void    ResolveWildcards(const String& path);
    void    AddMultiFile(const String& path);

private: // fields
    XmlConfigDocument&    document;
    Version               documentSchemaVersion;
    Attributes            additionalAttributes;
    PlaceholderExpression placeholderExpression;

private: // static fields
};

// inline methods of class XmlContext

inline Version XmlSerializationContext::GetDocumentSchemaVersion() const
{
    return this->documentSchemaVersion;
}

inline XmlConfigDocument& XmlSerializationContext::GetDocument()
{
    return this->document;
}

inline String& XmlSerializationContext::operator[](const String& attributeName)
{
    return this->additionalAttributes[attributeName];
}

inline const String& XmlSerializationContext::operator[](const String& attributeName)const
{
    auto i = this->additionalAttributes.find(attributeName);
    if (i == this->additionalAttributes.end())
    {
        throw KeyNotFoundException::Create(attributeName);
    }
    // else
    return i->second;
}

inline String XmlSerializationContext::ResolvePlaceholder(const char* input)
{
    return this->placeholderExpression.Resolve(input);
}


}}}} // end of namespace Arp::System::Commons::Xml