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 Arp::Plc::Commons::Esm::ProgramProviderBase;
using namespace Arp::Plc::Commons::Meta::TypeSystem;
 
 
class DataInfoProvider : public IDataInfoProvider
{
    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) override = default;
 
public: // getter properties
    const String& GetLibraryNamespace() const;
 
    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            AddDataInfo(const DataInfo& dataInfo);
    void            EnsureValidName(const DataInfo& dataInfo) const;
    void            RemoveDataInfo(const String& localVariableName);
 
private: // fields
    String                  libraryNamespace;
    ProgramProviderBase*    pProgramProvider = nullptr; // Deprecated (binary compatibility). Keeping track of programs is handled in ProgamProviderBase.
    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