aikido::robot Namespace Reference

Namespaces
	util

Classes
class	ConcreteManipulator
	A concrete implementation of a manipulator. More...
class	ConcreteRobot
struct	GrabMetadata
	Stores metadata for grabbed objects. More...
class	Hand
	Abstract class for Hand interface. More...
class	Manipulator
	Base interface for manipulator. More...
class	Robot
	Robot interface for defining basic behaviors of a robot. More...

Typedefs
using	ConcreteManipulatorPtr = std::shared_ptr< ConcreteManipulator >
using	ConstConcreteManipulatorPtr = std::shared_ptr< const ConcreteManipulator >
using	WeakConcreteManipulatorPtr = std::weak_ptr< ConcreteManipulator >
using	WeakConstConcreteManipulatorPtr = std::weak_ptr< const ConcreteManipulator >
using	UniqueConcreteManipulatorPtr = std::unique_ptr< ConcreteManipulator >
using	UniqueConstConcreteManipulatorPtr = std::unique_ptr< const ConcreteManipulator >
using	ConcreteRobotPtr = std::shared_ptr< ConcreteRobot >
using	ConstConcreteRobotPtr = std::shared_ptr< const ConcreteRobot >
using	WeakConcreteRobotPtr = std::weak_ptr< ConcreteRobot >
using	WeakConstConcreteRobotPtr = std::weak_ptr< const ConcreteRobot >
using	UniqueConcreteRobotPtr = std::unique_ptr< ConcreteRobot >
using	UniqueConstConcreteRobotPtr = std::unique_ptr< const ConcreteRobot >
using	HandPtr = std::shared_ptr< Hand >
using	ConstHandPtr = std::shared_ptr< const Hand >
using	WeakHandPtr = std::weak_ptr< Hand >
using	WeakConstHandPtr = std::weak_ptr< const Hand >
using	UniqueHandPtr = std::unique_ptr< Hand >
using	UniqueConstHandPtr = std::unique_ptr< const Hand >
using	ManipulatorPtr = std::shared_ptr< Manipulator >
using	ConstManipulatorPtr = std::shared_ptr< const Manipulator >
using	WeakManipulatorPtr = std::weak_ptr< Manipulator >
using	WeakConstManipulatorPtr = std::weak_ptr< const Manipulator >
using	UniqueManipulatorPtr = std::unique_ptr< Manipulator >
using	UniqueConstManipulatorPtr = std::unique_ptr< const Manipulator >
using	RobotPtr = std::shared_ptr< Robot >
using	ConstRobotPtr = std::shared_ptr< const Robot >
using	WeakRobotPtr = std::weak_ptr< Robot >
using	WeakConstRobotPtr = std::weak_ptr< const Robot >
using	UniqueRobotPtr = std::unique_ptr< Robot >
using	UniqueConstRobotPtr = std::unique_ptr< const Robot >

Typedef Documentation

ConcreteManipulatorPtr

using aikido::robot::ConcreteManipulatorPtr = typedef std::shared_ptr< ConcreteManipulator >

ConcreteRobotPtr

using aikido::robot::ConcreteRobotPtr = typedef std::shared_ptr< ConcreteRobot >

ConstConcreteManipulatorPtr

using aikido::robot::ConstConcreteManipulatorPtr = typedef std::shared_ptr< const ConcreteManipulator >

ConstConcreteRobotPtr

using aikido::robot::ConstConcreteRobotPtr = typedef std::shared_ptr< const ConcreteRobot >

ConstHandPtr

using aikido::robot::ConstHandPtr = typedef std::shared_ptr< const Hand >

ConstManipulatorPtr

using aikido::robot::ConstManipulatorPtr = typedef std::shared_ptr< const Manipulator >

ConstRobotPtr

using aikido::robot::ConstRobotPtr = typedef std::shared_ptr< const Robot >

HandPtr

using aikido::robot::HandPtr = typedef std::shared_ptr< Hand >

ManipulatorPtr

using aikido::robot::ManipulatorPtr = typedef std::shared_ptr< Manipulator >

RobotPtr

using aikido::robot::RobotPtr = typedef std::shared_ptr< Robot >

UniqueConcreteManipulatorPtr

using aikido::robot::UniqueConcreteManipulatorPtr = typedef std::unique_ptr< ConcreteManipulator >

UniqueConcreteRobotPtr

using aikido::robot::UniqueConcreteRobotPtr = typedef std::unique_ptr< ConcreteRobot >

UniqueConstConcreteManipulatorPtr

using aikido::robot::UniqueConstConcreteManipulatorPtr = typedef std::unique_ptr< const ConcreteManipulator >

UniqueConstConcreteRobotPtr

using aikido::robot::UniqueConstConcreteRobotPtr = typedef std::unique_ptr< const ConcreteRobot >

UniqueConstHandPtr

using aikido::robot::UniqueConstHandPtr = typedef std::unique_ptr< const Hand >

UniqueConstManipulatorPtr

using aikido::robot::UniqueConstManipulatorPtr = typedef std::unique_ptr< const Manipulator >

UniqueConstRobotPtr

using aikido::robot::UniqueConstRobotPtr = typedef std::unique_ptr< const Robot >

UniqueHandPtr

using aikido::robot::UniqueHandPtr = typedef std::unique_ptr< Hand >

UniqueManipulatorPtr

using aikido::robot::UniqueManipulatorPtr = typedef std::unique_ptr< Manipulator >

UniqueRobotPtr

using aikido::robot::UniqueRobotPtr = typedef std::unique_ptr< Robot >

WeakConcreteManipulatorPtr

using aikido::robot::WeakConcreteManipulatorPtr = typedef std::weak_ptr< ConcreteManipulator >

WeakConcreteRobotPtr

using aikido::robot::WeakConcreteRobotPtr = typedef std::weak_ptr< ConcreteRobot >

WeakConstConcreteManipulatorPtr

using aikido::robot::WeakConstConcreteManipulatorPtr = typedef std::weak_ptr< const ConcreteManipulator >

WeakConstConcreteRobotPtr

using aikido::robot::WeakConstConcreteRobotPtr = typedef std::weak_ptr< const ConcreteRobot >

WeakConstHandPtr

using aikido::robot::WeakConstHandPtr = typedef std::weak_ptr< const Hand >

WeakConstManipulatorPtr

using aikido::robot::WeakConstManipulatorPtr = typedef std::weak_ptr< const Manipulator >

WeakConstRobotPtr

using aikido::robot::WeakConstRobotPtr = typedef std::weak_ptr< const Robot >

WeakHandPtr

using aikido::robot::WeakHandPtr = typedef std::weak_ptr< Hand >

WeakManipulatorPtr

using aikido::robot::WeakManipulatorPtr = typedef std::weak_ptr< Manipulator >

WeakRobotPtr

using aikido::robot::WeakRobotPtr = typedef std::weak_ptr< Robot >