StateHandle.hpp

#ifndef AIKIDO_STATESPACE_STATEHANDLE_HPP_
#define AIKIDO_STATESPACE_STATEHANDLE_HPP_

#include <type_traits>

namespace aikido {
namespace statespace {

template <class _StateSpace, class _QualifiedState>
class StateHandle
{
public:
  using StateSpace = _StateSpace;
  using QualifiedState = _QualifiedState;

  using State = typename StateSpace::State;
  using ConstState = typename std::conditional<
      std::is_const<QualifiedState>::value,
      QualifiedState,
      const QualifiedState>::type;

  StateHandle();

  StateHandle(const StateSpace* space, QualifiedState* state);

  StateHandle(const StateHandle&) = default;
  StateHandle(StateHandle&&) = default;

  StateHandle& operator=(StateHandle&&) = default;
  StateHandle& operator=(const StateHandle&) = default;

  operator QualifiedState*() const;

  void reset();

  void reset(const StateSpace* space, QualifiedState* state);

  template <typename Q = QualifiedState>
  auto getState() ->
      typename std::enable_if<!std::is_const<Q>::value, Q*>::type;
  // Note: We don't define non-const function for const State type because it
  // violates const-correctness.

  template <typename Q = QualifiedState>
  auto getState() const ->
      typename std::conditional<std::is_const<Q>::value, Q*, const Q*>::type;

  const StateSpace* getStateSpace() const;

protected:
  const StateSpace* mSpace;

  QualifiedState* mState;
};

} // namespace statespace
} // namespace aikido

#include "detail/StateHandle-impl.hpp"

#endif // AIKIDO_STATESPACE_STATEHANDLE_HPP_