Parameters.h

Go to the documentation of this file.

/*
 * Copyright (C) 2018 Istituto Italiano di Tecnologia (IIT)
 * All rights reserved.
 *
 * This software may be modified and distributed under the terms of the
 * GNU Lesser General Public License v2.1 or any later version.
 */

#ifndef BLOCKFACTORY_CORE_PARAMETERS_H
#define BLOCKFACTORY_CORE_PARAMETERS_H

#include <memory>
#include <string>
#include <vector>

namespace blockfactory {
    namespace core {
        template <typename T>
        class Parameter;
        class ParameterMetadata;
        class Parameters;
        const int PARAM_INVALID_INDEX = -1;
        const std::string PARAM_INVALID_NAME = {};
    } // namespace core
} // namespace blockfactory

class blockfactory::core::Parameters
{
public:
    using ParamIndex = int;
    using ParamName = std::string;

private:
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    class impl;
    std::unique_ptr<impl> pImpl;
#endif

public:
    Parameters();
    Parameters(const blockfactory::core::Parameters& other);
    Parameters& operator=(const Parameters& other);

    ~Parameters();

    ParamName getParamName(const ParamIndex& index) const;

    ParamIndex getParamIndex(const ParamName& name) const;

    unsigned getNumberOfParameters() const;

    bool existName(const ParamName& name) const;

    template <typename T>
    bool storeParameter(const T& param, const blockfactory::core::ParameterMetadata& paramMetadata);

    template <typename T>
    bool storeParameter(const std::vector<T>& param,
                        const blockfactory::core::ParameterMetadata& paramMetadata);

    template <typename T>
    bool storeParameter(const Parameter<T>& parameter);

    template <typename T>
    bool getParameter(const ParamName& name, T& param) const;

    template <typename T>
    bool getParameter(const ParamName& name, std::vector<T>& param) const;

    std::vector<Parameter<int>> getIntParameters() const;

    std::vector<Parameter<bool>> getBoolParameters() const;

    std::vector<Parameter<double>> getDoubleParameters() const;

    std::vector<Parameter<std::string>> getStringParameters() const;

    blockfactory::core::ParameterMetadata getParameterMetadata(const ParamName& name);
};

// ============
// GETPARAMETER
// ============

// SCALAR
namespace blockfactory {
    namespace core {
        // Explicit declaration for numeric types
        extern template bool Parameters::getParameter<int>(const Parameters::ParamName& name,
                                                           int& param) const;
        extern template bool Parameters::getParameter<bool>(const Parameters::ParamName& name,
                                                            bool& param) const;
        extern template bool Parameters::getParameter<double>(const Parameters::ParamName& name,
                                                              double& param) const;
        // Explicit specialization for std::string
        template <>
        bool Parameters::getParameter<std::string>(const Parameters::ParamName& name,
                                                   std::string& param) const;
    } // namespace core
} // namespace blockfactory

// VECTOR
namespace blockfactory {
    namespace core {
        // Explicit declaration for numeric types
        extern template bool Parameters::getParameter<int>(const Parameters::ParamName& name,
                                                           std::vector<int>& param) const;
        extern template bool Parameters::getParameter<bool>(const Parameters::ParamName& name,
                                                            std::vector<bool>& param) const;
        extern template bool Parameters::getParameter<double>(const Parameters::ParamName& name,
                                                              std::vector<double>& param) const;
        extern template bool
        Parameters::getParameter<std::string>(const Parameters::ParamName& name,
                                              std::vector<std::string>& param) const;
    } // namespace core
} // namespace blockfactory

// ==============
// STOREPARAMETER
// ==============

// SCALAR
namespace blockfactory {
    namespace core {
        // Explicit declaration for numeric types
        extern template bool
        Parameters::storeParameter<int>(const int& param, const ParameterMetadata& paramMetadata);
        extern template bool
        Parameters::storeParameter<bool>(const bool& param, const ParameterMetadata& paramMetadata);
        extern template bool
        Parameters::storeParameter<double>(const double& param,
                                           const ParameterMetadata& paramMetadata);
        // Explicit specialization for std::string
        template <>
        bool Parameters::storeParameter<std::string>(const std::string& param,
                                                     const ParameterMetadata& paramMetadata);
    } // namespace core
} // namespace blockfactory

// VECTOR
namespace blockfactory {
    namespace core {
        // Explicit declaration for numeric types
        extern template bool
        Parameters::storeParameter<int>(const std::vector<int>& param,
                                        const ParameterMetadata& paramMetadata);
        extern template bool
        Parameters::storeParameter<bool>(const std::vector<bool>& param,
                                         const ParameterMetadata& paramMetadata);
        extern template bool
        Parameters::storeParameter<double>(const std::vector<double>& param,
                                           const ParameterMetadata& paramMetadata);
        extern template bool
        Parameters::storeParameter<std::string>(const std::vector<std::string>& param,
                                                const ParameterMetadata& paramMetadata);
    } // namespace core
} // namespace blockfactory

// PARAMETER
namespace blockfactory {
    namespace core {
        // Explicit declaration for numeric types
        extern template bool Parameters::storeParameter<int>(const Parameter<int>& parameter);
        extern template bool Parameters::storeParameter<bool>(const Parameter<bool>& parameter);
        extern template bool Parameters::storeParameter<double>(const Parameter<double>& parameter);
        extern template bool
        Parameters::storeParameter<std::string>(const Parameter<std::string>& parameter);
    } // namespace core
} // namespace blockfactory

#endif // BLOCKFACTORY_CORE_PARAMETERS_H