PropertyDefinition.h

Go to the documentation of this file.

/*
 * This file is part of ArmarX.
 *
 * Copyright (C) 2011-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/>.
 *
 * @package    ArmarXCore::core
 * @author     Jan Issac (jan dot issac at gmx dot de)
 * @date       2011
 * @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
 *             GNU General Public License
 */
 
 
#pragma once
 
 
#include <ArmarXCore/core/application/properties/PropertyDefinitionInterface.h>
#include <ArmarXCore/core/application/properties/PropertyDefinitionFormatter.h>
#include <ArmarXCore/core/exceptions/local/InvalidPropertyValueException.h>
#include <ArmarXCore/core/exceptions/local/MissingRequiredPropertyException.h>
#include <ArmarXCore/core/exceptions/local/UnmappedValueException.h>
#include <ArmarXCore/core/exceptions/local/ValueRangeExceededException.h>
 
#include <Ice/Handle.h>
 
#include <type_traits>
#include <functional>
#include <memory>
#include <string>
#include <map>
 
namespace Ice
{
    class Properties;
    class LocalObject;
    ICE_API ::Ice::LocalObject* upCast(::Ice::Properties*);
    typedef ::IceInternal::Handle< ::Ice::Properties> PropertiesPtr;
}
 
namespace armarx::meta::properties
{
    template<class T, class = void>
    struct GetPropertyPlugin : std::false_type {};
 
    template<class T, class = void>
    struct DefinePropertyPlugin : std::false_type {};
 
    template<class T, class = void>
    struct MapPropertyValuePlugin : std::false_type {};
 
    template<class T, class = void>
    struct DefaultAsStringPlugin : std::false_type {};
 
    template<class T, class = void>
    struct PDInitHookPlugin : std::false_type {};
}
 
namespace armarx
{
    template<typename PropertyType>
    class PropertyDefinition :
        public PropertyDefinitionBase
    {
    public:
        using PropertyTypePtr = std::shared_ptr<PropertyType>;
        using ValueEntry = std::pair<std::string, PropertyType>;
        using PropertyValuesMap = std::map<std::string, ValueEntry>;
        typedef std::function<PropertyType(std::string)> PropertyFactoryFunction;
 
        PropertyDefinition(
            PropertyType* setterRef,
            const std::string& propertyName,
            const std::string& description,
            PropertyDefinitionBase::PropertyConstness constness = PropertyDefinitionBase::eConstant);
 
 
        PropertyDefinition(
            PropertyType* setterRef,
            const std::string& propertyName,
            PropertyType defaultValue,
            const std::string& description,
            PropertyDefinitionBase::PropertyConstness constness = PropertyDefinitionBase::eConstant);
 
        PropertyDefinition<PropertyType>& map(const std::string& valueString, PropertyType value);
 
 
        PropertyDefinition<PropertyType>& map(const std::map<std::string, PropertyType>& values);
 
        template<class T>
        std::enable_if_t < std::is_same_v<T, PropertyType>&& !std::is_same_v<T, std::string>, PropertyDefinition<T>& >
        map(const std::map<T, std::string>& values);
 
        template<class T>
        std::enable_if_t<meta::properties::MapPropertyValuePlugin<T>::value, PropertyDefinition<PropertyType>& >
        map(const T& values)
        {
            return meta::properties::MapPropertyValuePlugin<T>::Map(*this, values);
        }
 
        PropertyDefinition<PropertyType>& setFactory(const PropertyFactoryFunction& func);
 
        PropertyDefinition<PropertyType>& setCaseInsensitive(bool isCaseInsensitive);
 
        PropertyDefinition<PropertyType>& setExpandEnvironmentVariables(bool expand);
 
        PropertyDefinition<PropertyType>& setRemoveQuotes(bool removeQuotes);
 
        PropertyDefinition<PropertyType>& setMatchRegex(const std::string& expr);
 
        PropertyDefinition<PropertyType>&
        setMin(double min);
 
        template<class T = PropertyType>
        PropertyDefinition<PropertyType>& setMin(std::array<T, 1> min)
        {
            return setMin(min.at(0));
        }
 
        PropertyDefinition<PropertyType>&
        setMax(double max);
 
        template<class T = PropertyType>
        PropertyDefinition<PropertyType>& setMax(std::array<T, 1> max)
        {
            return setMax(max.at(0));
        }
 
        bool isCaseInsensitive() const;
        bool expandEnvironmentVariables() const;
        bool removeQuotes() const;
        std::string getMatchRegex() const;
        double getMin() const;
        double getMax() const;
        std::string getPropertyName() const;
        PropertyValuesMap& getValueMap();
        PropertyType getDefaultValue();
        PropertyFactoryFunction getFactory() const;
        std::string getDefaultAsString() override;
 
        PropertyType getValue(const std::string& prefix, Ice::PropertiesPtr);
        bool isSet(const std::string& prefix, Ice::PropertiesPtr iceProperties) const;
 
        virtual
        void
        writeValueToSetter(
            const std::string& prefix,
            Ice::PropertiesPtr) override;
 
        static void removeQuotes(const std::string& input, std::string& output);
 
        std::string toString(PropertyDefinitionFormatter& formatter, const std::string& value) override;
 
        std::string getDescription() const;
 
    protected:
 
        PropertyValuesMap propertyValuesMap;
 
        std::string propertyName;
 
        std::string description;
 
        PropertyType defaultValue;
 
        PropertyType* setterRef;
 
        PropertyFactoryFunction factory;
 
        std::string regex;
 
        bool caseInsensitive;
 
        bool expandEnvVars;
 
        bool stringRemoveQuotes;
 
        double max;
 
        double min;
 
    private:
 
        void initHook();
 
        PropertyType getValueRequired(const std::string& prefix, Ice::PropertiesPtr iceProperties);
        PropertyType getValueOptional(const std::string& prefix, Ice::PropertiesPtr iceProperties);
 
        std::string getPropertyValue(const std::string& prefix, Ice::PropertiesPtr iceProperties) const;
 
        std::string getRawPropertyValue(const std::string& prefix, Ice::PropertiesPtr iceProperties) const;
 
        void checkRequirement(const std::string& prefix, Ice::PropertiesPtr iceProperties);
 
        bool matchRegex(const std::string& value) const;
 
        template <typename T>
        T processMappedValue(const T& value);
 
        std::string processMappedValue(const std::string& value);
 
        void checkLimits(const std::string& prefix, PropertyType numericValue) const;
 
        static bool expandEnvironmentVariables(const std::string& input, std::string& output);
 
    };
 
    // Helper functions to prevent boost include files
    std::string PropertyDefinition_lexicalCastToString(double input);
    std::string PropertyDefinition_lexicalCastToString(float input);
    std::string PropertyDefinition_lexicalCastToString(long input);
    std::string PropertyDefinition_lexicalCastToString(int input);
    std::string PropertyDefinition_lexicalCastToString(unsigned long input);
    std::string PropertyDefinition_lexicalCastToString(unsigned int input);
    std::string PropertyDefinition_lexicalCastToString(std::string const& input);
 
    template <typename T>
    T PropertyDefinition_lexicalCastTo(std::string const& input);
 
    template <>
    double PropertyDefinition_lexicalCastTo<double>(std::string const& input);
    template <>
    float PropertyDefinition_lexicalCastTo<float>(std::string const& input);
    template <>
    long PropertyDefinition_lexicalCastTo<long>(std::string const& input);
    template <>
    int PropertyDefinition_lexicalCastTo<int>(std::string const& input);
    template <>
    unsigned long PropertyDefinition_lexicalCastTo<unsigned long>(std::string const& input);
    template <>
    unsigned int PropertyDefinition_lexicalCastTo<unsigned int>(std::string const& input);
    template <>
    char PropertyDefinition_lexicalCastTo<char>(std::string const& input);
    template <>
    unsigned char PropertyDefinition_lexicalCastTo<unsigned char>(std::string const& input);
    template <>
    bool PropertyDefinition_lexicalCastTo<bool>(std::string const& input);
 
 
    extern template class PropertyDefinition<int>;
    extern template class PropertyDefinition<float>;
    extern template class PropertyDefinition<double>;
    extern template class PropertyDefinition<std::string>;
    extern template class PropertyDefinition<bool>;
}