State.hpp

#pragma once
 
#include <cassert>
#include <chrono>
#include <iostream>
#include <memory>
#include <typeinfo>
 
#include <eigen3/Eigen/Core>
#include <eigen3/Eigen/Dense>
 
#include "state_representation/StateType.hpp"
#include "state_representation/MathTools.hpp"
 
namespace state_representation {
 
class State : public std::enable_shared_from_this<State> {
public:
  explicit State();
 
  explicit State(const StateType& type);
 
  explicit State(const StateType& type, const std::string& name, const bool& empty = true);
 
  State(const State& state);
 
  virtual ~State() = default;
 
  friend void swap(State& state1, State& state2);
 
  State& operator=(const State& state);
 
  const StateType& get_type() const;
 
  bool is_empty() const;
 
  void set_empty(bool empty = true);
 
  void set_filled();
 
  const std::chrono::time_point<std::chrono::steady_clock>& get_timestamp() const;
 
  void set_timestamp(const std::chrono::time_point<std::chrono::steady_clock>& timepoint);
 
  void reset_timestamp();
 
  const std::string& get_name() const;
 
  virtual void set_name(const std::string& name);
 
  template<typename DurationT>
  bool is_deprecated(const std::chrono::duration<int64_t, DurationT>& time_delay);
 
  virtual bool is_compatible(const State& state) const;
 
  virtual void initialize();
 
  virtual void set_data(const Eigen::VectorXd& data);
 
  virtual void set_data(const std::vector<double>& data);
 
  virtual void set_data(const Eigen::MatrixXd& data);
 
  friend std::ostream& operator<<(std::ostream& os, const State& state);
 
  explicit operator bool() const noexcept;
 
protected:
  void set_type(const StateType& type);
 
private:
  StateType type_;                                              
  std::string name_;                                            
  bool empty_;                                                  
  std::chrono::time_point<std::chrono::steady_clock> timestamp_;
};
 
inline void swap(State& state1, State& state2) {
  std::swap(state1.type_, state2.type_);
  std::swap(state1.name_, state2.name_);
  std::swap(state1.empty_, state2.empty_);
  std::swap(state1.timestamp_, state2.timestamp_);
}
 
inline State& State::operator=(const State& state) {
  State tmp(state);
  swap(*this, tmp);
  return *this;
}
 
template<typename DurationT>
inline bool State::is_deprecated(const std::chrono::duration<int64_t, DurationT>& time_delay) {
  return ((std::chrono::steady_clock::now() - this->timestamp_) > time_delay);
}
 
template<typename T>
std::shared_ptr<State> make_shared_state(const T& state) {
  return std::make_shared<T>(state);
}
 
}// namespace state_representation