runtime: Fix Vehicle error handling

Author: cassava

runtime/include/cloe/vehicle.hpp

@@ -38,6 +38,55 @@
 
 namespace cloe {
 
+/**
+ * This error is thrown when an unknown component is accessed at a Vehicle.
+ */
+class UnknownComponent : public Error {
+ public:
+  UnknownComponent(const std::string& vehicle,
+                   const std::string& key,
+                   const std::vector<std::string>& available_components);
+
+  const std::string& vehicle() const { return vehicle_; }
+  const std::string& unknown_component() const { return unknown_; }
+  const std::vector<std::string>& available_components() const;
+
+ private:
+  std::string vehicle_;
+  std::string unknown_;
+  std::vector<std::string> available_;
+};
+
+/**
+ * This error is thrown when a component is cast to an incorrect type.
+ */
+class BadComponentCast : public Error {
+ public:
+  BadComponentCast(const std::string& vehicle, const std::string& key);
+
+  const std::string& vehicle() const { return vehicle_; }
+  const std::string& component_name() const { return component_; }
+
+ private:
+  std::string vehicle_;
+  std::string component_;
+};
+
+/**
+ * This error is thrown when a component cannot be added.
+ */
+class CannotAddComponent : public Error {
+ public:
+  CannotAddComponent(const std::string& msg, const std::string& vehicle, const std::string& key);
+
+  const std::string& vehicle() const { return vehicle_; }
+  const std::string& component_name() const { return component_; }
+
+ private:
+  std::string vehicle_;
+  std::string component_;
+};
+
 /**
  * A Vehicle is a collection of sensor and actuator components.
  *
@@ -91,36 +140,40 @@ class Vehicle : public Model {
   }
 
   /**
-   * Return the component with the given key if it exists.
+   * Return the component associated with the key.
    *
-   * This may throw std::out_of_range.
+   * This may throw one of:
+   * - UnknownComponent
+   * - BadComponentCast
    */
+  template <typename T>
+  std::shared_ptr<const T> get(const std::string& key) const {
+    auto ptr = std::dynamic_pointer_cast<const T>(at(key));
+    if (ptr == nullptr) {
+      throw BadComponentCast(name(), key);
+    }
+    return ptr;
+  }
+
   template <typename T>
   std::shared_ptr<T> get(const std::string& key) {
-    return std::dynamic_pointer_cast<T>(at(key));
+    return std::const_pointer_cast<T>(const_cast<const Vehicle&>(*this).get<T>(key));
   }
 
   /**
-   * Return the component associated with the standard Cloe enum value.
+   * Return the component associated with the enum value.
    *
    * Under-the-hood, the enum is translated to a string, which is used to fetch
    * the correct component.
-   *
-   * This may throw std::out_of_range.
    */
   template <typename T, typename Enum, std::enable_if_t<std::is_enum<Enum>::value, int> = 0>
-  std::shared_ptr<T> get(Enum c) {
-    return std::dynamic_pointer_cast<T>(at(to_string(c)));
-  }
-
-  template <typename T>
-  std::shared_ptr<const T> get(const std::string& key) const {
-    return std::dynamic_pointer_cast<const T>(at(key));
+  std::shared_ptr<const T> get(Enum c) const {
+    return get<T>(to_string(c));
   }
 
   template <typename T, typename Enum, std::enable_if_t<std::is_enum<Enum>::value, int> = 0>
-  std::shared_ptr<const T> get(Enum c) const {
-    return std::dynamic_pointer_cast<T>(at(to_string(c)));
+  std::shared_ptr<T> get(Enum c) {
+    return get<T>(to_string(c));
   }
 
  public:  // Component Management
@@ -144,8 +197,7 @@ class Vehicle : public Model {
 
   void add_component(std::shared_ptr<Component> sp, const std::string& alias) {
     if (this->has(alias)) {
-      // TODO(ben): Add better error type here with explanation
-      throw std::runtime_error("component already exists in the vehicle");
+      throw CannotAddComponent("component already exists", name(), alias);
     }
     this->set_component(alias, sp);
   }
@@ -230,25 +282,6 @@ class Vehicle : public Model {
   std::map<std::string, std::shared_ptr<Component>> components_;
 };
 
-/**
- * This error is thrown when an unknown component is accessed at a Vehicle.
- */
-class UnknownComponentError : public Error {
- public:
-  UnknownComponentError(const std::string& vehicle,
-                        const std::string& key,
-                        const std::vector<std::string>& available_components);
-
-  const std::string& vehicle() const { return vehicle_; }
-  const std::string& unknown_component() const { return unknown_; }
-  const std::vector<std::string>& available_components() const;
-
- private:
-  std::string vehicle_;
-  std::string unknown_;
-  std::vector<std::string> available_;
-};
-
 }  // namespace cloe
 
 #endif  // CLOE_VEHICLE_HPP_

runtime/src/cloe/vehicle.cpp

@@ -99,17 +99,17 @@ std::shared_ptr<const Component> Vehicle::at(const std::string& key) const {
   try {
     return components_.at(key);
   } catch (std::out_of_range& e) {
-    throw UnknownComponentError(name(), key, utility::map_keys(components_));
+    throw UnknownComponent(name(), key, utility::map_keys(components_));
   }
 }
 
 std::shared_ptr<Component> Vehicle::at(const std::string& key) {
   return std::const_pointer_cast<Component>(const_cast<const Vehicle&>(*this).at(key));
 }
 
-UnknownComponentError::UnknownComponentError(const std::string& vehicle,
-                                             const std::string& key,
-                                             const std::vector<std::string>& available_components)
+UnknownComponent::UnknownComponent(const std::string& vehicle,
+                                   const std::string& key,
+                                   const std::vector<std::string>& available_components)
     : Error("vehicle {}: no component available with name: {}", vehicle, key)
     , vehicle_(vehicle)
     , unknown_(key)
@@ -132,9 +132,58 @@ UnknownComponentError::UnknownComponentError(const std::string& vehicle,
        i) configuring it in the stackfile at /vehicles/<index>/components/<key>, or
        ii) adding it to the vehicle in the simulator binding plugin.
 
-  Note: You can also use the web API to inspect a vehicle during runtime.
+  Note: You can also use the web API to inspect a vehicle during run-time.
   )", key, utility::join_vector(available_, "\n         "));
   // clang-format on
 }
 
+BadComponentCast::BadComponentCast(const std::string& vehicle, const std::string& key)
+    : Error("vehicle {}: bad component cast with name: {}", vehicle, key)
+    , vehicle_(vehicle)
+    , component_(key) {
+  // clang-format off
+  this->set_explanation(R"(
+  The dynamic pointer cast returned a nullptr.
+
+  It looks like you are trying to cast a component to a type that does not match
+  the component's actual type.
+
+  This error can have several causes, in order of likelihood:
+
+    a) The component key is incorrect (see the stackfile).
+    b) The developer wrote the wrong type (see the controller source code).
+    c) The component has the correct type, but is a nullptr.
+
+  Note: You can use the web API to inspect a vehicle during run-time.
+  )");
+  // clang-format on
+}
+
+CannotAddComponent::CannotAddComponent(const std::string& msg,
+                                       const std::string& vehicle,
+                                       const std::string& key)
+    : Error("vehicle {}: {}: {}", vehicle, msg, key), vehicle_(vehicle), component_(key) {
+  // clang-format off
+  this->set_explanation(R"(
+  It looks like you are trying to add a component to a vehicle, but the component
+  already exists:
+
+      {}
+
+  This error can have several causes, in order of likelihood:
+
+    a) The component name has been copy-pasted and should be modified (see the
+       stackfile).
+
+    b) The component being added should use the set_component() method to allow
+       overwriting existing components (see the plugin source code).
+
+  Note: The component that already exists could have been added by the simulator
+  binding that originally created the vehicle (see /simulators section), added
+  by the component configuration (see /vehicles section), or even added by a
+  controller added to the vehicle (see /controllers section).
+  )", key);
+  // clang-format on
+}
+
 }  // namespace cloe