joint_state.h

Go to the documentation of this file.

 
#ifndef TESSERACT_COMMON_JOINT_STATE_H
#define TESSERACT_COMMON_JOINT_STATE_H
 
#include <tesseract_common/macros.h>
TESSERACT_COMMON_IGNORE_WARNINGS_PUSH
#include <boost/serialization/export.hpp>
#include <boost/serialization/version.hpp>
#include <boost/uuid/uuid.hpp>
#include <Eigen/Core>
#include <vector>
TESSERACT_COMMON_IGNORE_WARNINGS_POP
 
#include <tesseract_common/any_poly.h>
 
namespace boost::serialization
{
class access;
}
 
namespace tesseract_common
{
struct Serialization;
 
class JointState
{
public:
  JointState() = default;
  JointState(std::vector<std::string> joint_names, const Eigen::Ref<const Eigen::VectorXd>& position);
 
  std::vector<std::string> joint_names;
 
  Eigen::VectorXd position;
 
  Eigen::VectorXd velocity;
 
  Eigen::VectorXd acceleration;
 
  Eigen::VectorXd effort;
 
  double time{ 0 };
 
  bool operator==(const JointState& other) const;
 
  bool operator!=(const JointState& rhs) const;
 
private:
  friend class boost::serialization::access;
  friend struct tesseract_common::Serialization;
  template <class Archive>
  void serialize(Archive& ar, const unsigned int version);  // NOLINT
};
 
class JointTrajectory
{
public:
  JointTrajectory(std::string description = "");
  JointTrajectory(std::vector<JointState> states, std::string description = "");
 
  boost::uuids::uuid uuid{};
  std::vector<JointState> states;
  std::string description;
 
  bool operator==(const JointTrajectory& other) const;
 
  bool operator!=(const JointTrajectory& rhs) const;
 
  // C++ container support //
 
  using value_type = JointState;
  using pointer = typename std::vector<value_type>::pointer;
  using const_pointer = typename std::vector<value_type>::const_pointer;
  using reference = typename std::vector<value_type>::reference;
  using const_reference = typename std::vector<value_type>::const_reference;
  using size_type = typename std::vector<value_type>::size_type;
  using difference_type = typename std::vector<value_type>::difference_type;
  using iterator = typename std::vector<value_type>::iterator;
  using const_iterator = typename std::vector<value_type>::const_iterator;
  using reverse_iterator = typename std::vector<value_type>::reverse_iterator;
  using const_reverse_iterator = typename std::vector<value_type>::const_reverse_iterator;
 
  template <class InputIt>
  JointTrajectory(InputIt first, InputIt last) : states(first, last)
  {
  }
 
  // Iterators //
 
  iterator begin();
  const_iterator begin() const;
  iterator end();
  const_iterator end() const;
  reverse_iterator rbegin();
  const_reverse_iterator rbegin() const;
  reverse_iterator rend();
  const_reverse_iterator rend() const;
  const_iterator cbegin() const;
  const_iterator cend() const;
  const_reverse_iterator crbegin() const;
  const_reverse_iterator crend() const;
 
  // Capacity //
 
  bool empty() const;
  size_type size() const;
  size_type max_size() const;
  void reserve(size_type n);
  size_type capacity() const;
  void shrink_to_fit();
 
  // Element Access //
 
  reference front();
  const_reference front() const;
  reference back();
  const_reference back() const;
  reference at(size_type n);
  const_reference at(size_type n) const;
  pointer data();
  const_pointer data() const;
  reference operator[](size_type pos);
  const_reference operator[](size_type pos) const;
 
  // Modifiers //
 
  void clear();
  iterator insert(const_iterator p, const value_type& x);
  iterator insert(const_iterator p, value_type&& x);
  iterator insert(const_iterator p, std::initializer_list<value_type> l);
  template <class InputIt>
  void insert(const_iterator pos, InputIt first, InputIt last)
  {
    states.insert(pos, first, last);
  }
 
  template <class... Args>
  iterator emplace(const_iterator pos, Args&&... args);
 
  iterator erase(const_iterator p);
  iterator erase(const_iterator first, const_iterator last);
  void push_back(const value_type& x);
  void push_back(const value_type&& x);
 
  template <typename... Args>
#if __cplusplus > 201402L
  reference emplace_back(Args&&... args);
#else
  void emplace_back(Args&&... args);
#endif
 
  void pop_back();
  void swap(std::vector<value_type>& other) noexcept;
 
private:
  friend class boost::serialization::access;
  friend struct tesseract_common::Serialization;
  template <class Archive>
  void serialize(Archive& ar, const unsigned int version);  // NOLINT
};
 
using JointStateAnyPoly = AnyWrapper<JointState>;
using JointStatePtrAnyPoly = AnyWrapper<std::shared_ptr<JointState>>;
}  // namespace tesseract_common
 
BOOST_CLASS_EXPORT_KEY(tesseract_common::JointState)
BOOST_CLASS_EXPORT_KEY(tesseract_common::JointTrajectory)
BOOST_CLASS_EXPORT_KEY(tesseract_common::JointStateAnyPoly)
BOOST_CLASS_EXPORT_KEY(tesseract_common::JointStatePtrAnyPoly)
#endif  // TESSERACT_COMMON_JOINT_STATE_H