parameter.hpp

Go to the documentation of this file.

 
#ifndef CAMCOM_COMMON_PARAMETER_HPP
#define CAMCOM_COMMON_PARAMETER_HPP
 
#include <string>
#include <cmath>
#include <optional>
 
#include "camcom/common/tools.hpp"
#include "camcom/common/datatype.hpp"
#include "camcom/common/value.hpp"
#include "camcom/common/parameterMetadata.hpp"
#include "ifw/fnd/defs/base.hpp"
 
namespace camcom::common {
 
    class Parameter {
    public:
        Parameter(const std::string& name,
                  const Value& value,
                  const DataType& type);
        Parameter();
 
        template<typename T> Parameter(const std::string& name, const T& value) {
            m_name = name;
            m_value = value;
            if constexpr (std::is_same_v<T, int16_t>) {
                m_type = DataType::INT16;
            }
            else if constexpr (std::is_same_v<T, int32_t>) {
                m_type = DataType::INT32;
            }
            else if constexpr (std::is_same_v<T, int64_t>) {
                m_type = DataType::INT64;
            }
            else if constexpr (std::is_same_v<T, uint16_t>) {
                m_type = DataType::UINT16;
            }
            else if constexpr (std::is_same_v<T, uint32_t>) {
                m_type = DataType::UINT32;
            }
            else if constexpr (std::is_same_v<T, uint64_t>) {
                m_type = DataType::UINT64;
            }
            else if constexpr (std::is_same_v<T, float>) {
                m_type = DataType::FLOAT;
            }
            else if constexpr (std::is_same_v<T, double_t>) {
                m_type = DataType::DOUBLE;
            }
            else if constexpr (std::is_same_v<T, bool>) {
                m_type = DataType::BOOL;
            }
            else if constexpr (std::is_same_v<T, char>) {
                m_type = DataType::CHAR;
            }
            else if constexpr (std::is_same_v<T, std::string>) {
                m_type = DataType::STRING;
            }
            else if constexpr (std::is_same_v<T, std::byte>) {
                m_type = DataType::BYTE;
            }
        }
 
        const std::string GetName() const;
        void SetName(const std::string& name) { m_name = name; }
 
        const std::string GetValueAsString() const;
 
        template <typename T> const T GetValue() const {
            FNDTRACE();
            try {
                return std::get<T>(m_value);
            } catch (std::bad_variant_access&) {
                FNDTHROW("Illegal type: {} encountered - parameter: {}", typeid(T).name(), m_name);
                return T();
            }
        }
 
        const DataType& GetType() const;
        const std::string GetTypeAsString() const;
 
        void Store(const std::string& name, const Value& value, const DataType& type);
        template <typename T> void Store(const std::string& name, const T& value);
 
        const std::string ToString() const;
 
        // Metadata accessors
        bool HasMetadata() const { return m_metadata.has_value(); }
        const ParameterMetadata& GetMetadata() const;
        ParameterMetadata& GetMutableMetadata();
        void SetMetadata(const ParameterMetadata& metadata) { m_metadata = metadata; }
        void SetMetadata(ParameterMetadata&& metadata) { m_metadata = std::move(metadata); }
 
    private:
        std::string m_name;
        Value m_value;
        DataType m_type{DataType::UNSPECIFIED};
        std::optional<ParameterMetadata> m_metadata;
    };
 
    // Template specializations (declared here, defined in .cpp)
    template <> inline void Parameter::Store<int>(const std::string& name, const int& value) {
        m_name = name;
        m_value = value;
        m_type = DataType::INT32;
    }
 
    template <> inline void Parameter::Store<long>(const std::string& name, const long& value) {
        m_name = name;
        m_value = static_cast<int>(value);
        m_type = DataType::INT32;
    }
 
    template <> inline void Parameter::Store<float>(const std::string& name, const float& value) {
        m_name = name;
        m_value = value;
        m_type = DataType::FLOAT;
    }
 
    template <> inline void Parameter::Store<double_t>(const std::string& name, const double_t& value) {
        m_name = name;
        m_value = value;
        m_type = DataType::DOUBLE;
    }
 
    template <> inline void Parameter::Store<std::string>(const std::string& name, const std::string& value) {
        m_name = name;
        m_value = value;
        m_type = DataType::STRING;
    }
 
    template <> inline void Parameter::Store<const char*>(const std::string& name, const char* const& value) {
        m_name = name;
        m_value = value;
        m_type = DataType::STRING;
    }
 
    template <> inline void Parameter::Store<bool>(const std::string& name, const bool& value) {
        m_name = name;
        m_value = value;
        m_type = DataType::BOOL;
    }
 
}
 
#endif