EnumVariant.h

Go to the documentation of this file.

/*
 * This file is part of ArmarX.
 *
 * Copyright (C) 2012-2016, High Performance Humanoid Technologies (H2T),
 * Karlsruhe Institute of Technology (KIT), all rights reserved.
 *
 * ArmarX is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * ArmarX 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 this program. If not, see <http://www.gnu.org/licenses/>.
 *
 * @author     Fabian Peller-Konrad (fabian dot peller-konrad at kit dot edu)
 * @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
 *             GNU General Public License
 */
 
#pragma once
 
// STD/STL
#include <string>
 
// Base class
#include "SpecializedVariant.h"
 
// ArmarX
 
namespace armarx::aron::type::detail
{
    template <typename AronTypeT, typename DerivedT, typename ValueT>
    class EnumVariant : public SpecializedVariantBase<AronTypeT, DerivedT>
    {
    public:
        using ValueType = ValueT;
        using Base = SpecializedVariantBase<AronTypeT, DerivedT>;
 
        using Base::SpecializedVariantBase;
 
        virtual ~EnumVariant() = default;
 
        /* virtual implementations */
        VariantPtr
        navigateAbsolute(const Path& path) const override
        {
            throw error::AronException(
                __PRETTY_FUNCTION__,
                "Could not navigate through a non container navigator. The input path was: " +
                    path.toString(),
                Variant::getPath());
        }
 
        std::vector<VariantPtr>
        getChildren() const override
        {
            return {};
        }
 
        size_t
        childrenSize() const override
        {
            return 0;
        }
 
        void
        setAcceptedValueMap(const std::map<std::string, ValueType>& valueMap)
        {
            this->aron->acceptedValues = valueMap;
        }
 
        std::map<std::string, int>
        getAcceptedValueMap() const
        {
            return this->aron->acceptedValues;
        }
 
        std::vector<std::string>
        getAcceptedValueNames() const
        {
            std::vector<std::string> names;
            for (const auto& [k, _] : this->aron->acceptedValues)
            {
                names.push_back(k);
            }
            return names;
        }
 
        std::vector<ValueType>
        getAcceptedValues() const
        {
            std::vector<ValueType> vals;
            for (const auto& [_, i] : this->aron->acceptedValues)
            {
                vals.push_back(i);
            }
            return vals;
        }
 
        std::string
        getValueName(ValueType i) const
        {
            for (const auto& [k, v] : this->aron->acceptedValues)
            {
                if (v == i)
                {
                    return k;
                }
            }
            throw error::AronException(__PRETTY_FUNCTION__,
                                       "Enum could not be resolved. Input was: " +
                                           std::to_string(i),
                                       this->getPath());
        }
 
        int
        getValue(const std::string& s) const
        {
            return this->aron->acceptedValues[s];
        }
 
        std::string
        getEnumName() const
        {
            return this->aron->enumName;
        }
 
        void
        setEnumName(const std::string& s)
        {
            this->aron->enumName = s;
        }
 
        void
        addAcceptedValue(const std::string& s, ValueType i)
        {
            this->aron->acceptedValues[s] = i;
        }
 
        std::string
        getDefaultValueName() const
        {
            return this->aron->defaultValue;
        }
 
        ValueType
        getDefaultValue() const
        {
            //            ARMARX_CHECK(std::find(this->aron->acceptedValues.begin(),
            //                                   this->aron->acceptedValues.end(),
            //                                   this->aron->defaultValue) != this->aron->acceptedValues.end())
            //                << "An aron enum type has an invalid default value set. Got: "
            //                << this->aron->defaultValue;
            return this->aron->acceptedValues[this->aron->defaultValue];
        }
 
        void
        setDefaultValue(const ValueType& v)
        {
            for (const auto& [key, value] : this->aron->acceptedValues)
            {
                if (value == v)
                {
                    this->aron->defaultValue = key;
                }
            }
            throw error::ValueNotValidException(
                __PRETTY_FUNCTION__, "Got invalid input for enum value", std::to_string(v));
        }
 
        void
        setDefaultValueName(const std::string& v)
        {
            //            ARMARX_CHECK(std::find(this->aron->acceptedValues.begin(),
            //                                   this->aron->acceptedValues.end(),
            //                                   this->aron->defaultValue) != this->aron->acceptedValues.end())
            //                << "Trying to set an invalid default value for aron enum type. Got: "
            //                << this->aron->defaultValue;
            this->aron->defaultValue = v;
        }
    };
} // namespace armarx::aron::type::detail