XmlReader.hpp

 
//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#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 <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();
    bool Skip(); // TODO: remove this due to unclear naming
    bool SkipElement();
 
    bool SkipElementContent();
 
    // moves to the element that contains the current attribute
 
    bool MoveToElement();
    // moves to the next element with name
 
    bool ReadToFollowing(const String& name);
    // reads to the next element with name included in current element
 
    bool ReadToDescendant(const String& name);
    // skips the current element and reads until the next sibling with name
 
    bool ReadToNextSibling(const String& name);
 
    // reads to the next start element and tests the name against name, not needed after
    // ReadEndElement
 
    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);
    // reads the content as CData section of the current element
    // read CDATA is not required, ReadElementContent removes CDATA Tags automatically
    // String  ReadElementContentCData(void);
    // bool    TryReadElementContentCData(String& result);
 
    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)
    {
        char* charValue = GetAttributeValueInternal(attributeName);
        Chrono::Duration tempDurationValue;
 
        if (charValue == nullptr)
        {
            return false;
        }
 
        bool result = Chrono::Duration::TryParse(charValue, tempDurationValue);
        if (!result)
        {
            throw XmlException(
                "TryGetAttributeValueDuration failed for attribute '{0}' in element '{1}': invalid duration format in value '{2}'",
                attributeName, GetElementLocalName(), charValue);
        }
        tempDurationValue.GetDuration(value);
 
        FreeInternalAttributeValue(charValue);
        return result;
    }
 
    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;
            }
 
            // boost::lexical_cast seems fast enough:
            // http://stackoverflow.com/questions/23582089/is-boostlexical-cast-redundant-with-c11-stoi-stof-and-family
            // boost::lexical_cast is 10 times slower than atoi on Linux but has more error checks
            // http://tinodidriksen.com/2010/02/16/cpp-convert-string-to-int-speed/
            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);
    // Move to the content node, if the element is not an content node
    // content nodes are: non-whitespace text, CDATA, Element, EndElement, EntityReference,
    // EndEntity
    XmlNodeType MoveToContent();
    void EnableValidation(const String& xsdFile);
    void CheckForValidationException();
 
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...);
}
 
inline const String& XmlReader::GetDocumentFileName()
{
    return this->filename;
}
 
}}}} // namespace Arp::System::Commons::Xml