context.h

Go to the documentation of this file.

#pragma once

#include <memory>
#include <vector>

#include "drake/systems/framework/cache.h"
#include "drake/systems/framework/leaf_state_vector.h"
#include "drake/systems/framework/state.h"
#include "drake/systems/framework/system_input.h"
#include "drake/systems/framework/vector_interface.h"

namespace drake {
namespace systems {

// TODO(sherm1) Add step information.
template <typename T>
struct StepInfo {
  // TODO(sherm1): Consider whether this is sufficiently robust.
  T time_sec{};
};

// TODO(david-german-tri): Manage cache invalidation.
template <typename T>
class Context {
 public:
  Context() {}
  virtual ~Context() {}

  const T& get_time() const { return get_step_info().time_sec; }

  void set_time(const T& time_sec) {
    get_mutable_step_info()->time_sec = time_sec;
  }

  void SetInputPort(int index, std::unique_ptr<InputPort<T>> port) {
    if (index < 0 || index >= get_num_input_ports()) {
      throw std::out_of_range("Input port out of range.");
    }
    // TODO(david-german-tri): Set invalidation callbacks.
    inputs_[index] = std::move(port);
  }

  void ClearInputPorts() {
    inputs_.clear();
  }

  void SetNumInputPorts(int n) {
    ClearInputPorts();
    inputs_.resize(n);
  }

  int get_num_input_ports() const { return static_cast<int>(inputs_.size()); }

  const VectorInterface<T>* get_vector_input(int index) const {
    if (index >= get_num_input_ports()) {
      throw std::out_of_range("Input port out of range.");
    }
    if (inputs_[index] == nullptr) {
      return nullptr;
    }
    return inputs_[index]->get_vector_data();
  }

  const State<T>& get_state() const { return state_; }

  State<T>* get_mutable_state() { return &state_; }

  const Cache<T>& get_cache() const { return cache_; }

  Cache<T>* get_mutable_cache() const { return &cache_; }

  std::unique_ptr<Context<T>> Clone() const {
    return std::unique_ptr<Context<T>>(DoClone());
  }

 protected:
  virtual Context<T>* DoClone() const {
    Context<T>* context = new Context<T>();

    // Make a deep copy of the state using LeafStateVector::Clone().
    const ContinuousState<T>& xc = *this->get_state().continuous_state;
    const int num_q = xc.get_generalized_position().size();
    const int num_v = xc.get_generalized_velocity().size();
    const int num_z = xc.get_misc_continuous_state().size();
    const LeafStateVector<T>& xc_vector =
        dynamic_cast<const LeafStateVector<T>&>(xc.get_state());
    context->get_mutable_state()->continuous_state.reset(
        new ContinuousState<T>(xc_vector.Clone(), num_q, num_v, num_z));

    // Make deep copies of the inputs into FreestandingInputPorts.
    // TODO(david-german-tri): Preserve version numbers as well.
    for (const auto& port : this->inputs_) {
      context->inputs_.emplace_back(
          new FreestandingInputPort<T>(
              port->get_vector_data()->Clone(), port->get_sample_time_sec()));
    }

    // Make deep copies of everything else using the default copy constructors.
    *context->get_mutable_step_info() = this->get_step_info();
    *context->get_mutable_cache() = this->get_cache();
    return context;
  }

 private:
  // Returns a const reference to current time and step information.
  const StepInfo<T>& get_step_info() const { return step_info_; }

  // Provides writable access to time and step information, with the side
  // effect of invaliding any computation that is dependent on them.
  // TODO(david-german-tri) Invalidate all cached time- and step-dependent
  // computations.
  StepInfo<T>* get_mutable_step_info() { return &step_info_; }

  // Context objects are neither copyable nor moveable.
  Context(const Context& other) = delete;
  Context& operator=(const Context& other) = delete;
  Context(Context&& other) = delete;
  Context& operator=(Context&& other) = delete;

  // Current time and step information.
  StepInfo<T> step_info_;

  // The external inputs to the System.
  std::vector<std::unique_ptr<InputPort<T>>> inputs_;

  // The internal state of the System.
  State<T> state_;

  // The cache. The System may insert arbitrary key-value pairs, and configure
  // invalidation on a per-line basis.
  mutable Cache<T> cache_;
};

}  // namespace systems
}  // namesapce drake