DataInfoProvider.hpp

//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Core/Enumerator.hxx"
#include "Arp/Plc/Commons/Meta/IDataInfoProvider.hpp"
#include "Arp/Plc/Commons/Meta/TypeSystem/DataInfoDeduction.hxx"
#include "Arp/Plc/Commons/Esm/ProgramProviderBase.hpp"
#include "Arp/Plc/Commons/Meta/ChangeDataInfoProvider.hpp"
#include <map>

// forwards
namespace Arp { namespace Plc { namespace Commons { namespace Esm
{
class ProgramComponentBase;
}}}} // end of namespace Arp::Plc::Commons::Esm

namespace Arp { namespace Plc { namespace Commons { namespace Meta
{

// forwards
class ChangeDataInfoProvider;

using namespace Arp::Plc::Commons::Esm;
using namespace Arp::Plc::Commons::Meta::TypeSystem;

class DataInfoProvider : public IDataInfoProvider
{
    friend class Arp::Plc::Commons::Esm::ProgramComponentBase;
    friend class Arp::Plc::Commons::Meta::ChangeDataInfoProvider;

public: // typedefs/usings
    using Roots = std::map<String, DataInfo>;

private: // nested types
    class RootsEnumerator : public Enumerator<const DataInfo&>
    {
    public: // construcion
        RootsEnumerator(const Roots& roots);

    public: // Enumerator<DataInfo> operations
        bool        MoveNext(void)override;

    private:
        const Roots&            roots;
        Roots::const_iterator   currentIterator;
        Roots::const_iterator   endIterator;
        bool                    isFirstMove = true;
    };

public: // construction/destruction
    DataInfoProvider(const char* libraryNamespace, ProgramProviderBase* pProgramProvider = nullptr);
    DataInfoProvider(const DataInfoProvider& arg) = default;
    DataInfoProvider(DataInfoProvider&& arg) = default;
    DataInfoProvider& operator=(const DataInfoProvider& arg) = default;
    DataInfoProvider& operator=(DataInfoProvider&& arg) = default;
    ~DataInfoProvider(void) = default;

public: // getter properties
    IDataInfoProvider&  GetBackgroundProvider(void);

public: // operations
    void    Reset(void);
    void    AddRootInfo(const DataInfo& rootInfo);
    void    RemoveRootInfo(const String& name);

    template<class T>
    void    AddRoot(const char* name, const T& value);

public: // IDataInfoProvider operations
    IEnumerator<const DataInfo&>::Ptr   GetRoots(void)override;
    DataInfo                            GetRoot(const String& name)override;

private: // methods
    void            SetProgramProvider(ProgramProviderBase* pProgramProvider);
    void            OnProgramAdded(IProgram::Ptr programPtr);
    void            OnProgramRemoved(IProgram::Ptr programPtr);
    DataInfo        CreateDataInfo(const String& name, IProgram& program);
    TypeIdentifier  CreateTypeId(const String& commonTypeName);
    void            AddDataInfo(const DataInfo& dataInfo);
    void            RemoveDataInfo(const String& localVariableName);

private: // fields
    String                  libraryNamespace;
    ProgramProviderBase*    pProgramProvider = nullptr;
    Roots                   roots;
    ChangeDataInfoProvider  backgroundProvider;
};

// inline methods of class DataInfoProvider

inline void DataInfoProvider::AddRootInfo(const DataInfo& rootInfo)
{
    this->AddDataInfo(rootInfo);
}

inline void DataInfoProvider::RemoveRootInfo(const String& name)
{
    this->roots.erase(name);
}

template<class T>
inline void DataInfoProvider::AddRoot(const char* name, const T& value)
{
    DataInfoDeduction getDataInfo(this->libraryNamespace);
    this->AddDataInfo(getDataInfo(name, value));
}

}}}} // end of namespace Arp::Plc::Commons::Meta