ArrayNavigator.hpp

 
//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Core/IEnumerator.hxx"
#include "Arp/Plc/Commons/Meta/DataInfo.hpp"
#include "Arp/Plc/Commons/Meta/TypeInfo.hpp"
#include "Arp/Plc/Commons/Meta/ITypeNavigator.hpp"
 
//TODO(OR): move to Arp/Plc/Commons/Internal/Meta
 
namespace Arp { namespace Plc { namespace Commons { namespace Meta
{
 
// Not documented because it shall be moved to internal namepsace
class ArrayNavigator
{
public: // usings
    using Ptr = std::shared_ptr<ArrayNavigator>;
 
public: // Nested types
 
    class Enumerator : public IEnumerator<const DataInfo&>
    {
    public: // construction
        Enumerator(DataInfo& dataInfo, size_t count, size_t dataSize);
 
    public: // overridden operations
        bool            MoveNext(void)override;
        const DataInfo& GetCurrent(void)override;
        size_t          GetCurrentIndex(void)const;
        size_t          GetCurrentOffset(void)const;
        const byte*     GetCurrentAddress(void)const;
 
    private: // fields
        bool        isFirstMove = true;
        DataInfo&   dataInfo;
        size_t      count = 0;
        size_t      dataSize = 0;
        size_t      index = 0;
    };
 
 
public: // construction/destruction
    ArrayNavigator(const DataInfo& variableInfo, ITypeNavigator& typeNavigator);
 
public: // operators
 
public: // setter/getter operations
    Enumerator  GetEnumerator();
    size_t      GetElementDataSize(void)const;
 
public: // operations (convinience)
    size_t      GetOffset(size_t index);
    const byte* GetAddress(size_t index);
 
private: // methods
 
private: // fields
    size_t          elementDataSize = 0;
    DataInfo        dataInfo;
    ITypeNavigator& typeNavigator;
    const byte*     startAddress = nullptr;
    bool            isChanging = false;
};
 
// inline methods of class ArrayNavigator
inline size_t ArrayNavigator::GetOffset(size_t index)
{
    return index * this->elementDataSize;
}
 
inline const byte* ArrayNavigator::GetAddress(size_t index)
{
    return this->startAddress + this->GetOffset(index);
}
 
// inline methods of class ArrayNavigator::Enumerator
 
inline const DataInfo& ArrayNavigator::Enumerator::GetCurrent(void)
{
    return this->dataInfo;
}
 
inline size_t ArrayNavigator::Enumerator::GetCurrentIndex(void)const
{
    return this->index;
}
 
inline size_t ArrayNavigator::Enumerator::GetCurrentOffset(void)const
{
    return index * this->dataSize;
}
 
inline const byte* ArrayNavigator::Enumerator::GetCurrentAddress(void)const
{
    return this->dataInfo.GetDataTag().GetDataAddress();
}
 
inline size_t ArrayNavigator::GetElementDataSize(void)const
{
    return this->elementDataSize;
}
 
 
}}}} // end of namespace Arp::Plc::Commons::Meta