system3_input.h

Go to the documentation of this file.

#pragma once

#include <cstddef>
#include <functional>
#include <memory>
#include <string>
#include <utility>
#include <vector>

#include "drake/common/nice_type_name.h"
#include "drake/systems/framework/system3_output.h"
#include "drake/systems/framework/vector_interface.h"

namespace drake {
namespace systems {

// TODO(sherm1) Deal with sample rates.
class InputPort3 {
 public:
  InputPort3() {}

  // TODO(sherm1) Check that the output port's subsystem level makes sense.
  void ConnectTo(const OutputPort3* output_port) {
    CheckOutputPort(output_port);
    output_port_ = output_port;
  }

  void CheckOutputPort(const OutputPort3* proposed) const {
    if (proposed != nullptr) DoCheckOutputPort(*proposed);
  }

  const OutputPort3* get_connection() const { return output_port_; }

 protected:
  virtual void DoCheckOutputPort(const OutputPort3& proposed) const {}

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

  // Set backpointer; no ownership implied.
  void set_owner(AbstractSystem3* owner, int input_port_num) {
    system_ = owner;
    input_port_num_ = input_port_num;
  }

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

  // This is nullptr if this InputPort3 is not connected to an OutputPort3.
  const OutputPort3* output_port_{};
};

template <typename T>
class VectorInputPort3 : public InputPort3 {
 public:
  VectorInputPort3() {}

  explicit VectorInputPort3(int required_length)
      : required_length_(required_length) {
    DRAKE_ABORT_UNLESS(required_length >= -1);
    // TODO(sherm1) Should be an std::logic_error rather than abort().
  }

 private:
  void DoCheckOutputPort(const OutputPort3& proposed) const override {
    using namespace std::literals::string_literals;

    auto vector_output = dynamic_cast<const VectorOutputPort3<T>*>(&proposed);
    if (vector_output == nullptr) {
      throw std::logic_error(
          "VectorInputPort3::ConnectTo(): Proposed connection was not a "s +
          NiceTypeName::Get<VectorOutputPort3<T>>() + ".");
    }
    const int output_size = vector_output->get_model_vector().size();
    if (required_length_ >= 0 && output_size != required_length_) {
      throw std::out_of_range(
          "VectorInputPort3::ConnectTo(): "s +
          "Proposed connection was a VectorOutputPort3 of size " +
          std::to_string(output_size) + " but must be size " +
          std::to_string(required_length_) + " for this VectorInputPort3.");
    }
    // Looks good if we get here.
  }

  int required_length_{-1};  // Means "any length is OK".
};

}  // namespace systems
}  // namespace drake