value.h

Go to the documentation of this file.

#pragma once

#include <memory>
#include <stdexcept>
#include <string>
#include <typeinfo>

#include "drake/common/nice_type_name.h"
#include "drake/drakeSystemFramework_export.h"

namespace drake {
namespace systems {

template <typename T>
class Value;

class DRAKESYSTEMFRAMEWORK_EXPORT AbstractValue {
 public:
  AbstractValue() {}
  virtual ~AbstractValue() {}

  virtual std::unique_ptr<AbstractValue> Clone() const = 0;

  template <typename T>
  const T& GetValue() const {
    return DownCastOrMaybeThrow<T>()->get_value();
  }

  template <typename T>
  T* GetMutableValue() {
    return DownCastMutableOrMaybeThrow<T>()->get_mutable_value();
  }

  template <typename T>
  void SetValue(const T& value_to_set) {
    DownCastMutableOrMaybeThrow<T>()->set_value(value_to_set);
  }

 private:
  // Casts this class to a Value<T>*. In Debug builds, throws
  // std::bad_cast if the cast fails.
  template <typename T>
  Value<T>* DownCastMutableOrMaybeThrow() {
    // We cast away const in this private non-const method so that we can reuse
    // DownCastOrMaybeThrow. This is equivalent to duplicating the logic of
    // DownCastOrMaybeThrow with a non-const target type.
    return const_cast<Value<T>*>(DownCastOrMaybeThrow<T>());
  }

  // Casts this class to a const Value<T>*. In Debug builds, throws
  // std::logic_error if the cast fails.
  // TODO(david-german-tri): Use static_cast in Release builds for speed.
  template <typename T>
  const Value<T>* DownCastOrMaybeThrow() const {
    const Value<T>* value = dynamic_cast<const Value<T>*>(this);
    if (value == nullptr) {
      throw std::logic_error(
          "AbstractValue::DownCastOrMaybeThrow(): Can't downcast to type " +
          NiceTypeName::Get<T>() + ".");
    }
    return value;
  }
};

template <typename T>
class Value : public AbstractValue {
 public:
  explicit Value(const T& v) : value_(v) {}

  // Values are copyable but not moveable.
  Value(const Value<T>& other) = default;
  Value& operator=(const Value<T>& other) = default;
  Value(Value<T>&& other) = delete;
  Value& operator=(Value<T>&& other) = delete;

  std::unique_ptr<AbstractValue> Clone() const override {
    return std::make_unique<Value<T>>(*this);
  }

  const T& get_value() const { return value_; }

  T* get_mutable_value() { return &value_; }

  void set_value(const T& v) { value_ = v; }

 private:
  T value_;
};

}  // namespace systems
}  // namespace drake