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;
class MultiXmlConfigDocument;
 
// Never, ever use Loggable class here, because XmlSerializationContext is used before logging is initialized
class XmlSerializationContext // : private Loggable<XmlSerializationContext>
{
    friend class MultiXmlConfigDocument;
 
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  ResolveRelativePath(const String& path);
    String  ResolvePlaceholder(const char* input);
    //ist used by ReadIncludesElement
    void    AddIncludeFile(const String& path);
 
private: // static methods
    static void ResolveWildcards(const String& path, MultiXmlConfigDocument& doc);
 
private: // methods
    void    ResolveWildcards(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