CRNConfigElement.h

Go to the documentation of this file.

/* Copyright 2011-2016 CoReNum, INSA-Lyon, Université Paris Descartes, ENS-Lyon
 * 
 * This file is part of libcrn.
 * 
 * libcrn 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.
 * 
 * libcrn 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 libcrn.  If not, see <http://www.gnu.org/licenses/>.
 * 
 * file: CRNConfigElement.h
 * \author Yann LEYDIER
 */

#ifndef CRNConfigElement_HEADER
#define CRNConfigElement_HEADER

#include <CRNData/CRNVector.h>
#include <CRNData/CRNData.h>

namespace crn
{
    class ConfigElement
    {
        public:
            ConfigElement();
            ConfigElement(const String& nam, int val, const String& desc = U"");
            ConfigElement(const String& nam, double val, const String& desc = U"");
            ConfigElement(const String& nam, bool val, const String& desc = U"");
            ConfigElement(const String& nam, const Prop3& val, const String& desc = U"");
            ConfigElement(const String& nam, const String& val, const String& desc = U"");
            ConfigElement(const String& nam, const StringUTF8& val, const String& desc = U"");
            ConfigElement(const String& nam, const Path& val, const String& desc = U"");
            ConfigElement(const ConfigElement&) = delete;
            ConfigElement(ConfigElement&&) = default;
            ConfigElement& operator=(const ConfigElement&) = delete;
            ConfigElement& operator=(ConfigElement&&) = default;
            ~ConfigElement() = default;

            String GetType() const;
            const String& GetName() const noexcept { return name; }
            const String& GetDescription() const noexcept { return description; }
            const SObject& GetValue() noexcept { return value; }
            SCObject GetValue() const { return value; }
            template<typename T> T GetValue() const
            {
                return Data::Convert<T>(*value);
            }
            template<typename T> void SetValue(T val)
            {
                setValue(val, value);
            }
            bool HasMinValue() const noexcept { return minValue.get() != nullptr; }
            const SObject& GetMinValue() noexcept { return minValue; }
            SCObject GetMinValue() const { return minValue; }
            template<typename T> T GetMinValue() const
            {
                if (!minValue)
                    throw ExceptionUninitialized("The element has no minimal value.");
                return Data::Convert<T>(*minValue);
            }
            template<typename T> void SetMinValue(T val)
            {
                const String t(GetType());
                if (!minValue)
                    minValue = Clone(*value);
                setValue(val, minValue);
            }
            bool HasMaxValue() const noexcept { return maxValue.get() != nullptr; }
            const SObject& GetMaxValue() noexcept { return maxValue; }
            SCObject GetMaxValue() const { return maxValue; }
            template<typename T> T GetMaxValue() const
            {
                if (!maxValue)
                    throw ExceptionUninitialized("The element has no maximal value.");
                return Data::Convert<T>(*maxValue);
            }
            template<typename T> void SetMaxValue(T val)
            {
                const String t(GetType());
                if (!maxValue)
                    maxValue = Clone(*value);
                setValue(val, maxValue);
            }

            const crn::Vector& GetAllowedValues() const { return allowedValues; }
            template<typename T> const std::vector<T> GetAllowedValues() const
            {
                std::vector<T> lst;
                for (SCObject obj : allowedValues)
                {
                    lst.push_back(Data::Convert<T>(*obj));
                }
                return lst;
            }
            template<typename Iter> void SetAllowedValues(Iter b, Iter e)
            {
                allowedValues.Clear();
                for (Iter tmp = b; tmp != e; ++tmp)
                    AddAllowedValue(*tmp);
            }
            template<typename T> void AddAllowedValue(T val)
            {
                allowedValues.PushBack(Clone(*value));
                setValue(val, allowedValues.Back());
            }

        private:
            template<typename T> static void setValue(T val, const SObject &value)
            {
                const String valstring(val);
                auto i = std::static_pointer_cast<Int>(value);
                if (i)
                {
                    *i = valstring.ToInt();
                    return;
                }
                auto r = std::static_pointer_cast<Real>(value);
                if (r)
                {
                    *r = valstring.ToDouble();
                    return;
                }
                auto p = std::static_pointer_cast<Prop3>(value);
                if (p)
                {
                    *p = valstring.ToProp3();
                    return;
                }
                auto s = std::static_pointer_cast<String>(value);
                if (s)
                {
                    *s = valstring;
                    return;
                }
                auto su = std::static_pointer_cast<StringUTF8>(value);
                if (su)
                {
                    *su = valstring.CStr();
                    return;
                }
                auto pa = std::static_pointer_cast<Path>(value);
                if (pa)
                {
                    *pa = valstring.CStr();
                    return;
                }
            }
            
            SObject value; 
            SObject minValue; 
            SObject maxValue; 
            String name; 
            String description; 
            Vector allowedValues; 
    };

    CRN_ALIAS_SMART_PTR(ConfigElement)
}

#endif