XmlReader.hpp

 
//
//  Copyright Phoenix Contact GmbH & Co. KG
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Core/Enum.hxx"
#include "Arp/System/Core/TypeName.hxx"
#include "Arp/System/Commons/Chrono/Duration.hpp"
#include "Arp/System/Commons/Exceptions/Exceptions.h"
#include "Arp/System/Commons/Xml/XmlErrorHandler.hpp"
#include "Arp/System/Commons/Xml/XmlNodeType.hpp"
#include "Arp/Base/Core/Convert.hpp"
 
#include <sstream>
#include "boost/lexical_cast.hpp"
 
namespace Arp { namespace System { namespace Commons { namespace Xml
{
 
class LibXmlErrorHandler;
 
class XmlReader
{
public: // typedefs
public: // construction/destruction
    XmlReader(void);
    XmlReader(XmlReader&& arg);
    ~XmlReader(void);
 
private: // construction/destruction
    XmlReader(void* pReader);
    XmlReader(const XmlReader& arg) = delete;
    XmlReader& operator=(const XmlReader& arg) = delete;
 
public: // static factory operations
    static XmlReader Create(const String& filename);
    static bool TryCreate(const String& filename, XmlReader& reader);
 
    static XmlReader Create(const String& filename, const String& xsdFile);
    static XmlReader CreateForString(const String& buffer);
 
public: // setter/getter operations
    String GetElementLocalName(void);
    long GetLineNumber();
    const String& GetDocumentFileName();
 
public: // operations
    bool Read();
    XmlNodeType GetCurrentNodeType();
    bool IsEmptyElement();
    int GetCurrentDepth();
 
    ARP_DEPRECATED("Use SkipElement() instead.")
    bool Skip();
    bool SkipElement();
    bool SkipElementContent();
 
    bool MoveToElement();
 
    bool ReadToFollowing(const String& name);
    bool ReadToDescendant(const String& name);
    bool ReadToNextSibling(const String& name);
 
    void ReadStartElement(const char* elementName = nullptr);
    bool TryReadStartElement(const char* elementName = nullptr);
    bool TryReadStartElement(String& elementName, bool conditioned = true);
 
    void ReadEndElement(void);
    bool TryReadEndElement(void);
    String ReadElementContent(void);
 
    template<class T>
    T GetAndResolveAttributeValue(const char* attributeName);
 
    template<class T>
    bool TryGetAndResolveAttributeValue(const char* attributeName, T& value);
 
    template<class T>
    bool TryGetAndResolveAttributeValue(const char* attributeName, T defaultValue, T& value);
 
    template<class T>
    T ReadElementContent()
    {
        String elementString = this->ReadElementContent();
        try
        {
            return boost::lexical_cast<T>(elementString);
        }
        catch (std::exception& e)
        {
            throw XmlException::Create(
                this->GetDocumentFileName(),
                this->GetLineNumber(),
                "Cannot convert '{}' to {}: {}", elementString, TypeName<T>().GetFullName(), e.what());
        }
    }
 
    template<class T>
    T GetAttributeValue(const char* attributeName)
    {
        T returnValue;
        if (TryGetAttributeValue<T>(attributeName, returnValue))
        {
            return returnValue;
        }
        else
        {
            throw XmlException(
                "GetAttributeValue failed for mandatory attribute: {0} elementName: {1}",
                attributeName, GetElementLocalName());
        }
    }
 
    template<class T>
    Enum<T> GetAttributeValueEnum(const char* attributeName)
    {
        Enum<T> returnValue;
 
        if (TryGetAttributeValueEnum<T>(attributeName, returnValue))
        {
            return returnValue;
        }
        else
        {
            throw XmlException(
                "GetAttributeValueEnum failed for mandatory attribute: {0} elementName: {1}",
                attributeName, GetElementLocalName());
        }
    }
 
    template<class T>
    T GetAttributeValueOfEnum(const char* attributeName)
    {
        T result;
        if (!TryGetAttributeValueEnum<T>(attributeName, result))
        {
            throw XmlException(
                "GetAttributeValueOfEnum failed for mandatory attribute: {0} elementName: {1}", attributeName, GetElementLocalName());
        }
        return result;
    }
 
    template<class T>
    bool TryGetAttributeValueEnum(const char* attributeName, T& value)
    {
        char* charValue = GetAttributeValueInternal(attributeName);
        if (charValue == nullptr)
        {
            return false;
        }
        std::istringstream iss(charValue);
        iss >> value;
        FreeInternalAttributeValue(charValue);
        return true;
    }
 
    template<class T>
    bool TryGetAttributeValueEnum(const char* attributeName, Enum<T>& value)
    {
        char* charValue = GetAttributeValueInternal(attributeName);
        if (charValue == nullptr)
        {
            return false;
        }
 
        value = Enum<T>::Parse(charValue);
        FreeInternalAttributeValue(charValue);
        return true;
    }
 
    template<class T>
    bool TryGetAttributeValueEnum(const char* attributeName, T defaultValue, Enum<T>& value)
    {
        value = defaultValue;
        return TryGetAttributeValueEnum<T>(attributeName, value);
    }
 
 
    template<class T>
    T GetAttributeValueDuration(const char* attributeName)
    {
        T returnValue;
 
        if (TryGetAttributeValueDuration<T>(attributeName, returnValue))
        {
            return returnValue;
        }
        else
        {
            throw XmlException(
                "GetAttributeValueDuration failed for mandatory attribute: {0} elementName: {1}",
                attributeName, GetElementLocalName());
        }
    }
    template<class T>
    bool TryGetAttributeValueDuration(const char* attributeName, T& value)
    {
        return this->TryGetAttributeValue(attributeName, value);
    }
 
    template<class T>
    bool TryGetAttributeValueDuration(const char* attributeName, T defaultValue, T& value)
    {
        value = defaultValue;
        return TryGetAttributeValueDuration<T>(attributeName, value);
    }
 
 
    template<class T>
    bool TryGetAttributeValue(const char* attributeName, T& value)
    {
        char* charValue = nullptr;
        try
        {
            charValue = GetAttributeValueInternal(attributeName);
            if (charValue == nullptr)
            {
                return false;
            }
 
            value = boost::lexical_cast<T>(charValue);
            FreeInternalAttributeValue(charValue);
            return true;
        }
        catch (boost::bad_lexical_cast&)
        {
 
            String strValue(charValue);
            FreeInternalAttributeValue(charValue);
            throw XmlException("Cast of attribute {0} to {1} failed value: {2}", attributeName,
                               TypeName<T>(), strValue);
        }
    }
 
 
    template<class T>
    bool TryGetAttributeValue(const char* attributeName, T defaultValue, T& value)
    {
        value = defaultValue;
        return TryGetAttributeValue<T>(attributeName, value);
    }
 
    void EnableValidationException();
    void DisableValidationException();
 
    template<typename... Args>
    XmlException CreateException(const char* message, const Args& ... args);
 
protected: // operations
private:   // static methods
private:   // methods
    int ReaderState();
    char* GetAttributeValueInternal(const char* attributeName);
    void FreeInternalAttributeValue(char* attributeValue);
    XmlNodeType MoveToContent();
    void EnableValidation(const String& xsdFile);
    void CheckForValidationException();
    bool MoveToNextElement(void);
    String GetAndResolveAttributeValueInternal(const char* attributeName);
 
private: // fields
    String filename;
    // internal reader ptr
    void* reader;
    bool validationEnabled;
    LibXmlErrorHandler* errorHandler;
    bool exceptionOnValidationError; // defines whether to throw an exception when a validation
    // error occurs while parsing
    String lastError;
    bool startElementRead;
 
private: // static fields
};
 
// gcc does not allow full template specialization in class definition
// boost::lexical_cast does not understand true and false so implement special version
template<>
bool XmlReader::TryGetAttributeValue(const char*, bool& value);
 
template<>
bool XmlReader::TryGetAttributeValue(const char* attributeName, String& value);
 
template<>
bool XmlReader::TryGetAttributeValue(const char* attributeName, Chrono::Duration& value);
 
template<>
bool XmlReader::TryGetAttributeValue(const char* attributeName, uint8& value);
 
template<>
bool XmlReader::TryGetAttributeValue(const char* attributeName, int8& value);
 
// inline methods of class XmlReader
template<typename... Args>
inline XmlException XmlReader::CreateException(const char* message, const Args& ... args)
{
    return XmlException::Create(this->filename, this->GetLineNumber(), message, args...);
}
 
template<class T>
inline T XmlReader::GetAndResolveAttributeValue(const char* attributeName)
{
    T returnValue{};
    if (TryGetAndResolveAttributeValue(attributeName, returnValue))
    {
        return returnValue;
    }
    else
    {
        throw XmlException(
            "GetAndResolveAttributeValue failed for mandatory attribute: {0} elementName: {1}",
            attributeName, GetElementLocalName());
    }
}
 
template<class T>
inline bool XmlReader::TryGetAndResolveAttributeValue(const char* attributeName, T& value)
{
    String strValue{};
    try
    {
        strValue = this->GetAndResolveAttributeValueInternal(attributeName);
 
        if (strValue.IsEmpty())
        {
            return false;
        }
 
        value = Convert::ToValue<T>(strValue);
 
        return true;
    }
    catch (Exception&)
    {
        throw XmlException("Could not convert attribute {0} to {1} failed value: {2}", attributeName,
                           TypeName<T>(), strValue);
    }
}
 
template<class T>
inline bool XmlReader::TryGetAndResolveAttributeValue(const char* attributeName, T defaultValue, T& value)
{
    value = defaultValue;
    return  this->TryGetAndResolveAttributeValue(attributeName, value);
}
 
// inline methods
 
}}}} // namespace Arp::System::Commons::Xml