Added the PSim configuration/parameter system.

Author: kylekrol

.gitignore

@@ -153,3 +153,6 @@ bazel-out
 bazel-psim
 bazel-testlogs
 bazel-genfiles
+
+# Compiler commands from Bazel
+compile_commands.json

BUILD

@@ -57,18 +57,19 @@ cc_library(
 # Build all PSim models as a library
 #
 # This will be linked with executables later on.
-# cc_library(
-#     name = "psim",
-#     srcs = glob([
-#         "src/psim/**/*.hpp", "src/psim/**/*.inl", "src/psim/**/*.cpp",
-#     ]),
-#     hdrs = glob(
-#         ["include/psim/**/*.hpp", "include/psim/**/*.inl"],
-#         exclude = ["include/psim/**/*.yml.hpp"],
-#     ),
-#     includes = ["include"],
-#     copts = ["-Isrc"],
-#     linkstatic = True,
-#     visibility = ["//visibility:public"],
-#     deps = ["@lin//:lin", "//:gnc", "//:autocode"],
-# )
+cc_library(
+    name = "psim",
+    srcs = glob([
+        "src/psim/**/*.hpp", "src/psim/**/*.inl", "src/psim/**/*.cpp",
+        "include/psim/**/*.inl", # "include/psim/**/*.yml.hpp",
+    ]),
+    hdrs = glob(
+        ["include/psim/**/*.hpp"],
+        #exclude = ["include/psim/**/*.yml.hpp"],
+    ),
+    includes = ["include"],
+    copts = ["-Isrc"],
+    linkstatic = True,
+    visibility = ["//visibility:public"],
+    deps = ["@lin//:lin", "//:gnc"],# "//:autocode"],
+)

include/psim/core/configuration.hpp

@@ -0,0 +1,108 @@
+//
+// MIT License
+//
+// Copyright (c) 2020 Pathfinder for Autonomous Navigation (PAN)
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//
+
+/** @file psim/core/configuration.hpp
+ *  @author Kyle Krol
+ */
+
+#ifndef PSIM_CORE_CONFIGURATION_HPP_
+#define PSIM_CORE_CONFIGURATION_HPP_
+
+#include "parameter.hpp"
+#include "parameter_base.hpp"
+#include "types.hpp"
+
+#include <string>
+#include <unordered_map>
+
+namespace psim {
+
+/** @brief Represents a set of parameters used to initialize a simulation.
+ *
+ *  A configuration is a set of parameters parsed from a configuration file. These
+ *  parameters are made accesible to the simulation's models during intialization
+ *  to specify initial conditions and configure constants.
+ */
+class Configuration {
+ private:
+  /** @brief Map containing the parameter pointers.
+   */
+  std::unordered_map<std::string, ParameterBase const *> _parameters;
+
+  Configuration() = default;
+
+  /** @brief Adds a parameter and associates it with the specified name.
+   *
+   *  @param[in] name
+   *  @param[in] value
+   *
+   *  If a parameter has already been associated with the name, a runtime error is
+   *  thrown.
+   */
+  template <typename T>
+  void add(std::string const &name, T &&value);
+
+ public:
+  Configuration(Configuration const &) = delete;
+  Configuration &operator=(Configuration const &) = delete;
+
+  Configuration(Configuration &&config);
+  Configuration &operator=(Configuration &&config);
+
+  virtual ~Configuration();
+
+  /** @brief Retrives a parameter by name.
+   *
+   *  @param[in] name
+   *
+   *  @return Pointer to the parameter.
+   *
+   *  If no parameter is found by the specified name, a null pointer is returned.
+   */
+  ParameterBase const *get(std::string const &name) const;
+
+  /** @brief Retrives a parameter by name.
+   *
+   *  @param[in] name
+   *
+   *  @return Pointer to the parameter.
+   *
+   *  If no parameter is found by the specified name, a runtime error is thrown.
+   */
+  ParameterBase const &operator[](std::string const &name) const;
+
+  /** @brief Parses a configuration file into a set of parameters.
+   *
+   *  @param[in] file Configuration file.
+   *
+   *  @return Parameters.
+   *
+   *  If the configuration file doesn't exist, or a line with invalid formatting
+   *  is encountered, a runtime error will be thrown.
+   */
+  static Configuration make(std::string const &file);
+};
+}  // namespace psim
+
+#endif

include/psim/core/parameter.hpp

@@ -0,0 +1,159 @@
+//
+// MIT License
+//
+// Copyright (c) 2020 Pathfinder for Autonomous Navigation (PAN)
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//
+
+/** @file psim/core/parameters.hpp
+ *  @author Kyle Krol
+ */
+
+#ifndef PSIM_CORE_PARAMETER_HPP_
+#define PSIM_CORE_PARAMETER_HPP_
+
+#include "parameter_base.hpp"
+
+#include <type_traits>
+#include <utility>
+
+namespace psim {
+
+/** @brief Simulation parameter holding a single value of the underlying type.
+ *
+ *  @tparam T Underlying type.
+ */
+template <typename T>
+class Parameter : public ParameterBase {
+ private:
+  /** @brief Underlying value.
+   */
+  T _value;
+
+ public:
+  virtual ~Parameter() = default;
+
+  /** @brief Default constructs the parameter's initial value.
+   *
+   *  https://stackoverflow.com/questions/2417065/does-the-default-constructor-initialize-built-in-types
+   */
+  Parameter()
+      : _value() { }
+
+  /** @param[in] value Parameter's initial value.
+   *
+   *  @{
+   */
+  Parameter(T const &value)
+      : _value(value) { }
+
+  Parameter(T &&value)
+      : _value(std::move(value)) { }
+  /** @}
+   */
+
+  /** @param[in] value Parameter's initial value.
+   *
+   *  If the passed parameter's underlying type does not match, a runtime error
+   *  will be thrown.
+   *
+   *  @{
+   */
+  Parameter(ParameterBase const &param)
+      : _value(param.get<T>()) { }
+
+  Parameter(ParameterBase &&param)
+      : _value(std::move(param.get<T>())) { }
+  /** @}
+   */
+
+  /** @return Reference to the underlying type.
+   *
+   *  @{
+   */
+  operator T const & () const {
+    return _value;
+  }
+
+  operator T & () {
+    return _value;
+  }
+  /** @}
+   */
+
+  /** @param[in] value New value held by the parameter.
+   *
+   *  @return Reference to this parameter.
+   *
+   *  @{
+   */
+  Parameter<T> &operator=(T const &value) {
+    _value = value;
+  }
+
+  Parameter<T> &operator=(T &&value) {
+    _value = std::move(value);
+  }
+  /** @}
+   */
+
+  /** @param[in] param New value held by the parameter.
+   *
+   *  @return Reference to this parameter.
+   *
+   *  If the passed parameter's underlying type does not match a runtime error
+   *  will be thrown.
+   *
+   *  @{
+   */
+  Parameter<T> &operator=(ParameterBase const &param) {
+    _value = param.get<T>();
+  }
+
+  Parameter<T> &operator=(ParameterBase &&param) {
+    _value = std::move(param.get<T>());
+  }
+  /** @}
+   */
+
+  /** @returns Reference to the underlying value.
+   *
+   *  This function was re-implemented to avoid potential type checking overhead
+   *  and keep a consistant interface.
+   *
+   *  @{
+   */
+  template <typename U = T>
+  U const &get() const {
+    static_assert(std::is_same<U, T>::value, "Invalid parameter type in call to 'get'.");
+    return _value;
+  }
+
+  template <typename U = T>
+  U &get() {
+    static_assert(std::is_same<U, T>::value, "Invalid parameter type in call to 'get'.");
+    return _value;
+  }
+  /** @}
+   */
+};
+}  // namespace psim
+
+#endif

include/psim/core/parameter_base.hpp

@@ -0,0 +1,84 @@
+//
+// MIT License
+//
+// Copyright (c) 2020 Pathfinder for Autonomous Navigation (PAN)
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//
+
+/** @file psim/core/parameter_base.hpp
+ *  @author Kyle Krol
+ */
+
+#ifndef PSIM_CORE_PARAMETER_BASE_HPP_
+#define PSIM_CORE_PARAMETER_BASE_HPP_
+
+#include <stdexcept>
+
+namespace psim {
+
+template <typename T>
+class Parameter;
+
+/** @brief Virtual base class for all parameters.
+ *
+ *  The main purpose of this class is to allow dynamic casting to be used to check
+ *  parameter types at runtime and provide helpful casting functions.
+ */
+class ParameterBase {
+ protected:
+  ParameterBase() = default;
+
+ public:
+  virtual ~ParameterBase() = default;
+
+  /** @brief Attempt to get the parameter's underlying value.
+   *
+   *  @tparam Expected underlying type.
+   *
+   *  @return Reference to the underlying value.
+   *
+   *  If the underlying type doesn't match the expected underlying type, a runtime
+   *  error will be thrown.
+   *
+   *  @{
+   */
+  template <typename T>
+  T const &get() const {
+    auto const *param_ptr = dynamic_cast<Parameter<T> const *>(this);
+    if (!param_ptr)
+      throw std::runtime_error("Invalid parameter type in call to 'get'.");
+    
+    return (T const &) *param_ptr;
+  }
+
+  template <typename T>
+  T &get() {
+    auto *param_ptr = dynamic_cast<Parameter<T> *>(this);
+    if (!param_ptr)
+      throw std::runtime_error("Invalid parameter type in call to 'get'.");
+
+    return (T &) *param_ptr;
+  }
+  /** @}
+   */
+};
+}  // namespace psim
+
+#endif