TicConfigDocument.hxx

 
//
//  Copyright Phoenix Contact GmbH & Co. KG
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Commons/Configuration/TicReader.hpp"
#include "Arp/System/Commons/Configuration/TicSerializationContext.hpp"
#include <type_traits>
namespace Arp { namespace System { namespace Commons { namespace Configuration
{
 
// TContent policy: implements ITicSerializable and default contructable
template<class TContent>
class TicConfigDocument
{
public: // typedefs
    typedef TContent                                        Content;
    typedef typename TContent::Ptr                          ContentPtr;
    typedef std::shared_ptr<TicConfigDocument<TContent>>    Ptr;
 
public: // construction/destruction
    TicConfigDocument(ContentPtr contentPtr = nullptr);
    ~TicConfigDocument(void);
 
public: // setter/getter operations
    const String&   GetDocumentFilename(void)const;
    ContentPtr      GetContent(void);
 
public: // operations
    void    Load(const String& filename);
 
private: // deleted methods
    TicConfigDocument(const TicConfigDocument& arg) = delete;
    TicConfigDocument(TicConfigDocument&& other) noexcept = delete;
    TicConfigDocument& operator=(const TicConfigDocument& arg) = delete;
    TicConfigDocument& operator=(TicConfigDocument&& other) noexcept = delete;
 
private: // fields
    ContentPtr              contentPtr;
    String                  documentFilename;
};
 
// inline methods of class TicConfigDocument
template<class T>
inline TicConfigDocument<T>::TicConfigDocument(ContentPtr contentPtrArg)
    : contentPtr(contentPtrArg)
    , documentFilename()
{
    if (this->contentPtr == nullptr)
    {
        this->contentPtr = ContentPtr(new Content());
    }
}
 
template<class T>
inline TicConfigDocument<T>::~TicConfigDocument(void)
{
    if constexpr (std::is_pointer_v<ContentPtr>)
    {
        if (this->contentPtr != nullptr)
        {
            delete this->contentPtr;
            this->contentPtr = nullptr;
        }
    }
}
 
template<class T>
inline typename TicConfigDocument<T>::ContentPtr TicConfigDocument<T>::GetContent(void)
{
    return this->contentPtr;
}
 
template<class T>
inline const String& TicConfigDocument<T>::GetDocumentFilename(void)const
{
    return this->documentFilename;
}
 
template<class T>
inline void TicConfigDocument<T>::Load(const String& filename)
{
    TicReader reader = TicReader::Create(filename);
    TicSerializationContext context(reader);
 
    this->documentFilename = filename;
    context.SetFilePath(filename);
 
    // start reading
    reader.GetXmlReader().ReadStartElement("TIC");
    // read context
    context.ReadDocumentContext(reader);
    // read content
    this->contentPtr->ReadTic(reader, context);
    // end reading
    reader.GetXmlReader().ReadEndElement();
}
 
}}}} // end of namespace Arp::System::Commons::Configuration