SizeTypeInfo.h

/*****************************************************************************
 *
 * Copyright (C) 2021 Richard Hacker (lerichi at gmx dot net),
 *                    Florian Pose (fp at igh dot de),
 *                    Bjarne von Horn (vh at igh dot de).
 *
 * This file is part of the PdCom library.
 *
 * The PdCom library is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or (at your
 * option) any later version.
 *
 * The PdCom library is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
 * License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with the PdCom library. If not, see <http://www.gnu.org/licenses/>.
 *
 *****************************************************************************/

#ifndef PDCOM5_SIZETYPEINFO_H
#define PDCOM5_SIZETYPEINFO_H

#include <cstddef>
#include <vector>

namespace PdCom {

struct TypeInfo
{
    enum DataType {
        boolean_T = 0,
        uint8_T,
        int8_T,
        uint16_T,
        int16_T,
        uint32_T,
        int32_T,
        uint64_T,
        int64_T,
        double_T,
        single_T,
        DataTypeEnd  // keep this as the very last one!
    };

    DataType type;
    const char *ctype;
    size_t element_size;
    constexpr TypeInfo(
            DataType type,
            const char *ctype,
            size_t element_size) noexcept :
        type(type), ctype(ctype), element_size(element_size)
    {}
};

class SizeInfo
{
    using UnderlyingType = std::vector<unsigned int>;
    UnderlyingType size_info;

    SizeInfo(UnderlyingType size_info) : size_info(std::move(size_info)) {}

  public:
    SizeInfo() : size_info(1, 1U) {}
    bool isScalar() const
    {
        return size_info.size() == 1 and size_info[0] == 1;
    }
    bool isVector() const { return size_info.size() == 1 and size_info[0] > 1; }
    std::size_t dimension() const noexcept { return size_info.size(); }
    unsigned int operator[](std::size_t index) const
    {
        return size_info[index];
    }
    typename UnderlyingType::const_iterator begin() const
    {
        return size_info.begin();
    }

    typename UnderlyingType::const_iterator end() const
    {
        return size_info.end();
    }
    std::size_t totalElements() const
    {
        std::size_t ans = 1;
        for (auto i : size_info)
            ans *= i;
        return ans;
    }
    static SizeInfo RowVector(unsigned int rows) { return {{1, rows}}; }
    static SizeInfo Matrix(unsigned int rows, unsigned int cols)
    {
        UnderlyingType u {2, 0};
        u[0] = rows;
        u[1] = cols;
        return {u};
    }
};
}  // namespace PdCom


#endif  // PDCOM5_SIZETYPEINFO_H