system3_output.h

Go to the documentation of this file.

#pragma once

#include <memory>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>

#include "drake/drakeSystemFramework_export.h"
#include "drake/systems/framework/basic_vector.h"
#include "drake/systems/framework/value.h"
#include "drake/systems/framework/value_listener3.h"
#include "drake/systems/framework/vector_interface.h"

namespace drake {
namespace systems {

class AbstractSystem3;

class OutputPort3 {
 public:
  virtual ~OutputPort3() = default;

  OutputPort3() {}

  explicit OutputPort3(std::unique_ptr<AbstractValue> model_value)
      : OutputPort3() {
    set_model_value(std::move(model_value));
  }

  void set_model_value(std::unique_ptr<AbstractValue> model_value) {
    model_value_ = std::move(model_value);
  }

  const AbstractValue& get_model_value() const { return *model_value_; }

  AbstractValue* get_mutable_model_value() { return model_value_.get(); }

  std::pair<const AbstractSystem3*, int> get_owner_system() const {
    return std::pair<const AbstractSystem3*, int>(system_, output_port_num_);
  }

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

  friend class AbstractSystem3;  // Allow call to set_owner().

  // Set backpointer; no ownership implied.
  void set_owner(AbstractSystem3* system, int output_port_num) {
    system_ = system;
    output_port_num_ = output_port_num;
  }

  // This AbstractSystem is the owner of this OutputPort3, where it has this
  // port
  // number.
  AbstractSystem3* system_{};
  int output_port_num_{-1};

  std::unique_ptr<AbstractValue> model_value_;

  // The rate at which this port produces output, in seconds.
  // If zero, the port is continuous.
  double sample_time_sec_{0.};
};

template <typename T>
class VectorOutputPort3 : public OutputPort3 {
 public:
  explicit VectorOutputPort3(std::unique_ptr<VectorInterface<T>> model_value)
      : OutputPort3(std::make_unique<Value<VectorObject<T>>>(
            VectorObject<T>(std::move(model_value)))) {}

  explicit VectorOutputPort3(int length)
      : VectorOutputPort3(std::make_unique<BasicVector<T>>(length)) {}

  const VectorInterface<T>& get_model_vector() const {
    const auto& vector_object =
        get_model_value().template GetValue<VectorObject<T>>();
    return vector_object.get_vector();
  }

  VectorInterface<T>* get_mutable_model_vector() {
    auto vector_object =
        get_mutable_model_value()->template GetMutableValue<VectorObject<T>>();
    return vector_object->get_mutable_vector();
  }

 private:
  // VectorOutputPort3 objects are neither copyable nor moveable.
  VectorOutputPort3(const VectorOutputPort3& other) = delete;
  VectorOutputPort3& operator=(const VectorOutputPort3& other) = delete;
  VectorOutputPort3(VectorOutputPort3&& other) = delete;
  VectorOutputPort3& operator=(VectorOutputPort3&& other) = delete;
};

}  // namespace systems
}  // namespace drake