vector_interface.h

Go to the documentation of this file.

#pragma once

#include <cstdint>
#include <memory>

#include "drake/common/eigen_types.h"
#include "drake/systems/framework/value.h"

#include <Eigen/Dense>

namespace drake {
namespace systems {


// TODO(sherm1) Currently these must be contiguous. Is that reasonable?
template <typename T>
class VectorInterface {
 public:
  virtual ~VectorInterface() {}

  virtual int size() const = 0;

  virtual void set_value(const Eigen::Ref<const VectorX<T>>& value) = 0;

  virtual Eigen::VectorBlock<const VectorX<T>> get_value() const = 0;

  virtual Eigen::VectorBlock<VectorX<T>> get_mutable_value() = 0;

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

 protected:
  VectorInterface() {}

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

// TODO(sherm1) This wrapper would not be necessary if we had a smart
// pointer for adding object semantics to abstract objects that support Clone(),
// say copy_unique_ptr<T>. Consider adapting Simbody's ClonePtr<T>.
template <typename T>
class VectorObject {
 public:
  VectorObject() noexcept {}

  explicit VectorObject(std::unique_ptr<VectorInterface<T>> vector) noexcept
      : vector_(std::move(vector)) {}

  VectorObject(const VectorObject& source) : VectorObject() {
    if (!source.empty())
      vector_ = source.get_vector().Clone();
  }

  VectorObject(VectorObject&& source) noexcept
    : vector_(std::move(source.vector_)) {}

  VectorObject& operator=(const VectorObject& source) {
    vector_.reset();  // Delete current vector.
    if (!source.empty()) vector_ = source.get_vector().Clone();
    return *this;
  }

  VectorObject& operator=(VectorObject&& source) noexcept {
    vector_ = std::move(source.vector_);
    return *this;
  }

  const VectorInterface<T>& get_vector() const {
    if (empty())
      throw std::logic_error("VectorObject::get_vector(): object is empty.");
    return *vector_;
  }

  VectorInterface<T>* get_mutable_vector() {
    if (empty()) {
      throw std::logic_error(
          "VectorObject::get_mutable_vector(): object is empty.");
    }
    return vector_.get();
  }

  bool empty() const noexcept { return !vector_; }

 private:
  std::unique_ptr<VectorInterface<T>> vector_;
};

template <typename T>
inline const VectorInterface<T>& to_vector_interface(
    const AbstractValue& value) {
  const VectorObject<T>& object = value.GetValue<VectorObject<T>>();
  return object.get_vector();
}

template <typename T>
inline VectorInterface<T>* to_mutable_vector_interface(AbstractValue* value) {
  VectorObject<T>* object = value->GetMutableValue<VectorObject<T>>();
  return object->get_mutable_vector();
}

}  // namespace systems
}  // namespace drake