trajectory_id.h

Go to the documentation of this file.

#ifndef TRAJECTORY_ID_H
#define TRAJECTORY_ID_H

#include <iostream>

#include <boost/thread/mutex.hpp>

namespace descartes_core
{

namespace detail
{

template<typename T>
struct IdGenerator;

template<>
struct IdGenerator<uint64_t>
{
  typedef uint64_t value_type;

  static value_type make_nil()
  {
    return 0;
  }

  static value_type make_id()
  {
    boost::unique_lock<boost::mutex> scoped_lock (counter_mutex_);
    return counter_++;
  }

  static bool is_nil(value_type id)
  {
    return id == 0;
  }

private:
  // Initialized to 1
  static value_type counter_;
  static boost::mutex counter_mutex_;
};

}

template<typename T>
class TrajectoryID_
{
public:
  typedef T value_type;

  TrajectoryID_(value_type id)
    : id_(id)
  {}

  TrajectoryID_()
    : id_(detail::IdGenerator<value_type>::make_nil())
  {}

  bool is_nil() const { return detail::IdGenerator<value_type>::is_nil(id_); }

  value_type value() const { return id_; }

  static TrajectoryID_<value_type> make_id()
  {
    return TrajectoryID_<value_type>( detail::IdGenerator<value_type>::make_id() );
  }

  static TrajectoryID_<value_type> make_nil()
  {
    return TrajectoryID_<value_type>( detail::IdGenerator<value_type>::make_nil() );
  }

private:
  value_type id_;  
};

// Helper Functions //

template<typename T>
inline bool operator==(TrajectoryID_<T> lhs, TrajectoryID_<T> rhs)
{
  return lhs.value() == rhs.value();
}

template<typename T>
inline bool operator!=(TrajectoryID_<T> lhs, TrajectoryID_<T> rhs)
{
  return !(lhs == rhs);
}

template<typename T>
inline bool operator<(TrajectoryID_<T> lhs, TrajectoryID_<T> rhs)
{
  return lhs.value() < rhs.value();
}

template<typename T>
inline std::ostream& operator<<(std::ostream& os, TrajectoryID_<T> id)
{
  os << "ID" << id.value();
  return os;
}

typedef TrajectoryID_<uint64_t> TrajectoryID;

} // end namespace descartes_core


#endif