TicReader.hpp

 
//
//  Copyright Phoenix Contact GmbH & Co. KG
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Commons/Diagnostics/Logging/Loggable.hxx"
#include "Arp/System/Commons/Xml/XmlReader.hpp"
#include "Arp/System/Commons/Exceptions/XmlException.hpp"
#include "Arp/System/Commons/Configuration/TicNodeType.hpp"
#include "Arp/System/Commons/Configuration/TicSerializationContext.hpp"
#include <map>
#include <sstream>
 
namespace Arp { namespace System { namespace Commons { namespace Configuration
{
 
using namespace Arp::System::Commons::Diagnostics::Logging;
using namespace Arp::System::Commons::Xml;
 
class TicReader : private Loggable<TicReader>
{
    friend class TicSerializationContext;
 
private: // usings
    using TicNodeTypeNames = std::map<TicNodeType, String>;
    using TicNameNodeTypes = std::map<String, TicNodeType>;
 
public: // usings
    template<typename T>
    using SectionReadCallback = void (T::*)(TicReader& reader, TicSerializationContext& context);
 
public: // nested helper class
    template<class T>
    struct SectionReadCallbacks
    {
    public: // Static fields
        static SectionReadCallback<T> Null;
        static SectionReadCallback<T> Empty;
 
    private:
        void EmptySectionReadCallback(TicReader&, TicSerializationContext&) {}
    };
 
private: // construction
    TicReader(const String& filename);
 
public: // canonical construction/destruction/assignment
    TicReader(const TicReader& arg) = delete;
    TicReader(TicReader&& arg)noexcept;
    TicReader& operator=(const TicReader& arg) = delete;
    ~TicReader(void) = default;
 
public: // static operations
    static TicReader   Create(const String& filename);
 
public: // setter/getter operations
    XmlReader&  GetXmlReader(void);
 
public: // operations
    // read unknown tick node and determine nodeType
    void    ReadStartTicNode(TicNodeType& nodeType);
    bool    TryReadStartTicNode(TicNodeType& nodeType);
    void    ReadEndTicNode(TicNodeType nodeType);
    bool    TryReadEndTicNode(TicNodeType nodeType);
 
    // Read <EL> or </EL> nodes
    void    ReadStartTicElementList(void);
    bool    TryReadStartTicElementList(void);
    void    ReadEndTicElementList(void);
    bool    TryReadEndTicElementList(void);
 
    // Read <AL> or </AL> nodes
    void    ReadStartTicAttributeList(void);
    bool    TryReadStartTicAttributeList(void);
    void    ReadEndTicAttributeList(void);
    bool    TryReadEndTicAttributeList(void);
 
    // Read TIC element <E> or </E> nodes
    void    ReadStartTicElement(String& readELementName);
    bool    TryReadStartTicElement(String& readELementName);
    bool    TryReadStartTicElement(const String& elementName, String& readELementName);
    void    ReadEndTicElement(void);
    bool    TryReadEndTicElement(void);
 
    // Read TIC attribute <A> or </A> nodes
    void    ReadStartTicAttribute(String& readAttributeName);
    bool    TryReadStartTicAttribute(String& readAttributeName);
    bool    TryReadStartTicAttribute(const String& attributeName, String& readAttributeName);
    void    ReadEndTicAttribute(void);
    bool    TryReadEndTicAttribute(void);
 
    // Read TIC attribute values <V>...</V>
    void    SkipTicAttributeValue(void);
    template<class T>
    T       ReadTicAttributeValue(void);
    template<class T>
    bool    TryReadTicAttributeValue(T& result);
 
    // Read TIC element content containing one <AL>..</AL> (optional) and one <EL>..</EL> section (optional).
    template<class T>
    void    ReadTicElementContent(
        TicSerializationContext& context,
        T& configuration,
        SectionReadCallback<T> attributesReadMethod,
        SectionReadCallback<T> childElementsReadMethod = nullptr,
        bool attributesAreOptional = false,
        bool elementsAreOptional = false);
 
private: // methods
    bool    TryReadStartTicElement(const String& elementName, String& readELementName, String& errorMessage);
    bool    TryReadStartTicAttribute(const String& attributeName, String& readAttributeName, String& errorMessage);
    bool    TryReadTicAttributeContent(String& result, String& errorMessage);
    template<class T>
    bool    TryReadTicAttributeValue(T& result, String& errorMessage);
    void    SkipTicAttributeList(void);
    void    SkipTicElementList(void);
 
private: // fields
    XmlReader   xmlReader;
 
private: // static fields
    static TicNodeTypeNames    ticNodeTypeNames;
    static TicNameNodeTypes    ticNameNodeTypes;
 
private: // static const fields
    static const char* const ticElementNameAttributeName;
    static const char* const ticAttributeNameAttributeName;
};
 
// inline methods of class TicReader
 
template<class T>
inline T TicReader::ReadTicAttributeValue()
{
    T result;
    String errorMessage;
    if (!this->TryReadTicAttributeValue<T>(result, errorMessage))
    {
        throw XmlException(errorMessage);
    }
    return result;
}
 
template<class T>
inline bool TicReader::TryReadTicAttributeValue(T& result)
{
    String errorMessage;
    return this->TryReadTicAttributeValue<T>(result, errorMessage);
}
 
template<class T>
inline bool TicReader::TryReadTicAttributeValue(T& result, String& errorMessage)
{
    String attributeValue;
    if (!this->TryReadTicAttributeContent(attributeValue, errorMessage))
    {
        return false;
    }
    // else convert
    std::stringstream iss(attributeValue);
    iss >> std::boolalpha >> result;
    return !iss.fail();
}
template<>
inline bool TicReader::TryReadTicAttributeValue(String& result, String& errorMessage)
{
    String attributeValue;
    return this->TryReadTicAttributeContent(result, errorMessage);
    // else convert
    /*std::stringstream iss(attributeValue);
    iss >> boolalpha >> result;
    return !iss.fail();*/
}
 
template<class T>
inline void TicReader::ReadTicElementContent(
    TicSerializationContext& context,
    T& configuration,
    SectionReadCallback<T> attributesReader,
    SectionReadCallback<T> childElementsReader,
    bool attributesAreOptional,
    bool elementsAreOptional)
{
    bool hasAttributesRead = false;
    bool hasChildElementsRead = false;
 
    while (!(hasAttributesRead && hasChildElementsRead))
    {
        TicNodeType nodeType = TicNodeType::None;
        if (this->TryReadStartTicNode(nodeType))
        {
            bool mustReadEndTicNode = true;
            switch (nodeType)
            {
                case TicNodeType::AttributeList:
                    if (attributesReader == nullptr)
                    {
                        this->SkipTicAttributeList();
                    }
                    else
                    {
                        (configuration.*attributesReader)(*this, context);
                    }
                    hasAttributesRead = true;
                    break;
                case TicNodeType::ElementList:
                    if (childElementsReader == nullptr)
                    {
                        this->SkipTicElementList();
                        mustReadEndTicNode = false; // xmlReader.Skip() reads also EndElement of current node
                    }
                    else
                    {
                        (configuration.*childElementsReader)(*this, context);
                    }
                    hasChildElementsRead = true;
                    break;
                default:
                    throw XmlException("Invalid TIC file format: expecting attribute or element list");
                    break;
            }
            if(mustReadEndTicNode)
            {
                this->ReadEndTicNode(nodeType);
            }
        }
        else // a further start tic node could not be read
        {
            if (!hasAttributesRead && !attributesAreOptional)
            {
                throw XmlException("Invalid TIC file format: expecting attribute list");
            }
            else if (attributesReader == nullptr && attributesAreOptional)
            {
                hasAttributesRead = true;
            }
 
            if (!hasChildElementsRead && !elementsAreOptional)
            {
                throw XmlException("Invalid TIC file format: expecting element list");
            }
            else if (elementsAreOptional)
            {
                hasChildElementsRead = true;
            }
        }
    }
}
 
// initializing of static fields of class TicReader::SectionReadCallbacks
template<class T>
TicReader::SectionReadCallback<T> TicReader::SectionReadCallbacks<T>::Null = nullptr;
template<class T>
TicReader::SectionReadCallback<T> TicReader::SectionReadCallbacks<T>::Empty = &TicReader::SectionReadCallbacks<T>::EmptySectionReadCallback;
 
}}}} // end of namespace Arp::System::Commons::Configuration