ArrayDimensions.hpp

 
//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/Plc/Commons/Meta/ArrayDimension.hpp"
#include <vector>
#include <algorithm>
#include <initializer_list>
 
namespace Arp { namespace Plc { namespace Commons { namespace Meta
{
 
class ArrayDimensions
{
    friend class ArrayNavigator;
 
public: // typedefs
    using Values = std::vector<ArrayDimension>;
 
public: // construction/destruction
    ArrayDimensions(void) = default;
    explicit ArrayDimensions(size_t count);
    ArrayDimensions(const ArrayDimension& entry);
    ArrayDimensions(const Values& values);
    ArrayDimensions(const std::initializer_list<int>& dimensions);
    ArrayDimensions(const std::initializer_list<ArrayDimension>& entries);
    ArrayDimensions(const ArrayDimensions& arg) = default;
    ArrayDimensions(ArrayDimensions&& arg) = default;
    ArrayDimensions& operator=(const ArrayDimensions& arg) = default;
    ArrayDimensions& operator=(ArrayDimensions&& arg) = default;
    ~ArrayDimensions(void) = default;
 
public: // static properties
    static const ArrayDimensions Empty;
 
public: // operators
    ArrayDimension&         operator[](size_t index);
    const ArrayDimension&   operator[](size_t index)const;
 
public: // setter/getter operations
    bool            IsEmpty(void)const;
 
    size_t          GetCount(void)const;
    const Values&   GetValues(void)const;
 
    size_t          GetCacheSize(void)const;
 
    size_t          GetDimensionsProduct(void)const;
 
public: // operations
    void    Append(const ArrayDimension& dimension);
 
protected: // setter/getter operations
    void EraseFrontDimension(void);
 
private: // fields
    Values values;
};
 
// inline methods of class ArrayDimensions
inline ArrayDimensions::ArrayDimensions(size_t count)
    : values(count)
{
}
 
inline ArrayDimensions::ArrayDimensions(const ArrayDimension&  entry)
    : values(1, entry)
{
}
 
inline ArrayDimensions::ArrayDimensions(const Values& values)
    : values(values)
{
}
 
inline ArrayDimension& ArrayDimensions::operator[](size_t index)
{
    return this->values[index];
}
 
inline const ArrayDimension& ArrayDimensions::operator[](size_t index)const
{
    return this->values[index];
}
 
inline bool ArrayDimensions::IsEmpty()const
{
    return this->values.empty();
}
 
inline size_t ArrayDimensions::GetCount()const
{
    return this->values.size();
}
 
inline const ArrayDimensions::Values& ArrayDimensions::GetValues()const
{
    return this->values;
}
 
inline void ArrayDimensions::EraseFrontDimension(void)
{
    if (this->values.size() > 0)
    {
        this->values.erase(this->values.begin());
    }
}
 
inline void ArrayDimensions::Append(const ArrayDimension& dimension)
{
    this->values.push_back(dimension);
}
 
inline size_t ArrayDimensions::GetCacheSize(void)const
{
    return this->values.size() * ArrayDimension::GetCacheSize();
}
 
inline bool operator==(const ArrayDimensions& lhs, const ArrayDimensions& rhs)
{
    return (lhs.GetCount() == rhs.GetCount()) &&
           std::equal(lhs.GetValues().begin(), lhs.GetValues().end(), rhs.GetValues().begin());
}
 
inline bool operator!= (const ArrayDimensions& lhs, const ArrayDimensions& rhs)
{
    return !(lhs == rhs);
}
 
inline std::ostream& operator<<(std::ostream& os, const ArrayDimensions& rhs)
{
    if (rhs.GetCount() == 0)
    {
        os << "{}";
    }
    else
    {
        os << "{" << rhs[0];
        const auto count = rhs.GetCount();
        for (size_t i = 1; i < count; ++i)
        {
            os << ";" << rhs[i];
        }
        os << "}";
    }
    return os;
}
 
}}}} // end of namespace Arp::Plc::Commons::Meta