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;

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];
        for (size_t i = 1; i < rhs.GetCount(); ++i)
        {
            os << ";" << rhs[i];
        }
        os << "}";
    }
    return os;
}

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