system_interface.h

Go to the documentation of this file.

#pragma once

#include <string>

#include "drake/drakeSystemFramework_export.h"
#include "drake/systems/framework/cache.h"
#include "drake/systems/framework/context.h"
#include "drake/systems/framework/system_output.h"

namespace drake {
namespace systems {

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

  virtual std::string get_name() const = 0;

 protected:
  AbstractSystemInterface() {}

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

template <typename T>
class SystemInterface : public AbstractSystemInterface {
  // TODO(david-german-tri): Add static_asserts on T.
 public:
  virtual std::unique_ptr<Context<T>> CreateDefaultContext() const = 0;

  virtual std::unique_ptr<SystemOutput<T>> AllocateOutput() const = 0;

  virtual void EvalOutput(const Context<T>& context,
                          SystemOutput<T>* output) const = 0;

  // TODO(sherm): these two energy methods should be present only for systems
  // that represent some kind of physical system that can store energy in its
  // configuration or motion. Consider introducing a PhysicalSystemInterface
  // class so that a simple System (for example, an adder) doesn't have these
  // methods. For now I'm breaking the no-code-in-interface rule to provide
  // zero defaults so that these don't have to be implemented in non-physical
  // systems.

  virtual T EvalPotentialEnergy(const Context<T>& context) const {
    return T(0);
  }

  virtual T EvalKineticEnergy(const Context<T>& context) const { return T(0); }

 protected:
  SystemInterface() {}

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

}  // namespace systems
}  // namespace drake