IdSubscriptArray.h

Go to the documentation of this file.

/*
 *  This is free software: you can redistribute it and/or modify it
 *  under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  any later version.
 *  The software 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 General Public License for more details.
 *  You should have received a copy of the GNU General Public License
 *  along with the software. If not, see <http://www.gnu.org/licenses/>.
 *
 *  Copyright 2018, Kuylen E, Willem L, Broeckhove J
 */

#pragma once

#include "contact/ContactType.h"

#include <array>
#include <bitset>
#include <initializer_list>
#include <iostream>
#include <stdexcept>

namespace stride {
namespace ContactType {

template <class T>
class IdSubscriptArray : public std::array<T, NumOfTypes()>
{
public:
        explicit IdSubscriptArray(T t)
        {
                for (auto typ : IdList) {
                        this->operator[](typ) = t;
                }
        }

        explicit IdSubscriptArray()
        {
                for (auto typ : IdList) {
                        this->operator[](typ) = T();
                }
        }

        IdSubscriptArray(std::initializer_list<T> l)
        {
                auto it = l.begin();
                for (auto typ : IdList) {
                        if (it != l.end()) {
                                this->operator[](typ) = *it;
                                ++it;
                        } else {
                                this->operator[](typ) = T();
                        }
                }
        }

        explicit IdSubscriptArray(std::array<T, NumOfTypes()>&& l) : std::array<T, NumOfTypes()>(l) {}


        typename std::array<T, NumOfTypes()>::reference operator[](ContactType::Id id)
        {
                return this->std::template array<T, NumOfTypes()>::operator[](ContactType::ToSizeT(id));
        }

        typename std::array<T, NumOfTypes()>::const_reference operator[](ContactType::Id id) const
        {
                return this->std::template array<T, NumOfTypes()>::operator[](ContactType::ToSizeT(id));
        }

        typename std::array<T, NumOfTypes()>::reference at(ContactType::Id id)
        {
                if (ToSizeT(id) >= NumOfTypes()) {
                        throw std::out_of_range("IdSubscriptArray::at> Id out of range");
                }
                return this->std::template array<T, NumOfTypes()>::operator[](ContactType::ToSizeT(id));
        }

        typename std::array<T, NumOfTypes()>::const_reference at(ContactType::Id id) const
        {
                if (ToSizeT(id) >= NumOfTypes()) {
                        throw std::out_of_range("IdSubscriptArray::at> Id out of range");
                }
                return this->std::template array<T, NumOfTypes()>::operator[](ContactType::ToSizeT(id));
        }
};

template <>
class IdSubscriptArray<bool> : public std::bitset<NumOfTypes()>
{
public:
        explicit IdSubscriptArray(bool t = bool())
        {
                if (t)
                        this->set();
                else
                        this->reset();
        }

        IdSubscriptArray(std::initializer_list<bool> l)
        {
                auto it = l.begin();
                for (auto typ : IdList) {
                        if (it != l.end()) {
                                this->operator[](typ) = *it;
                                ++it;
                        } else {
                                this->operator[](typ) = bool();
                        }
                }
        }

        typename std::bitset<NumOfTypes()>::reference operator[](ContactType::Id id)
        {
                return this->std::template bitset<NumOfTypes()>::operator[](ContactType::ToSizeT(id));
        }

        bool operator[](ContactType::Id id) const
        {
                return this->std::template bitset<NumOfTypes()>::operator[](ContactType::ToSizeT(id));
        }

        typename bitset<NumOfTypes()>::reference at(ContactType::Id id)
        {
                if (ToSizeT(id) >= NumOfTypes()) {
                        throw std::out_of_range("IdSubscriptArray<bool>::at> Id out of range");
                }
                return this->std::template bitset<NumOfTypes()>::operator[](ContactType::ToSizeT(id));
        }

        bool at(ContactType::Id id) const
        {
                if (ToSizeT(id) >= NumOfTypes()) {
                        throw std::out_of_range("IdSubscriptArray::at> Id out of range");
                }
                return this->std::template bitset<NumOfTypes()>::operator[](ContactType::ToSizeT(id));
        }
};

} // namespace ContactType
} // namespace stride