DataHeader.h

Go to the documentation of this file.

// this is for emacs file handling -*- mode: c++; indent-tabs-mode: nil -*-

// -- BEGIN LICENSE BLOCK ----------------------------------------------
// This file is part of FZIs ic_workspace.
//
// This program is free software licensed under the LGPL
// (GNU LESSER GENERAL PUBLIC LICENSE Version 3).
// You can find a copy of this license in LICENSE folder in the top
// directory of the source code.
//
// © Copyright 2016 FZI Forschungszentrum Informatik, Karlsruhe, Germany
//
// -- END LICENSE BLOCK ------------------------------------------------

//----------------------------------------------------------------------
//----------------------------------------------------------------------
#ifndef ICL_CORE_DATA_HEADER_H_INCLUDED
#define ICL_CORE_DATA_HEADER_H_INCLUDED

#include <string>
#include <boost/shared_ptr.hpp>
#include <boost/date_time.hpp>
#include <boost/version.hpp>
#if (BOOST_VERSION >= 104800)
# include <boost/type_traits/has_left_shift.hpp>
#endif
#include <icl_core/ImportExport.h>
#include <icl_core/BaseTypes.h>

#ifdef _IC_BUILDER_EIGEN_
#include <Eigen/Core>
#endif

namespace icl_core {

struct DataHeader
{
  DataHeader()
    : coordinate_system(),
      timestamp(),
      sequence_number(0)
  { }

  DataHeader(const std::string& coordinate_system,
             const boost::posix_time::ptime& timestamp,
             uint32_t sequence_number = 0)
    : coordinate_system(coordinate_system),
      timestamp(timestamp),
      sequence_number(sequence_number)
  { }

  ~DataHeader()
  { }

  std::string coordinate_system;
  boost::posix_time::ptime timestamp;
  uint32_t sequence_number;
  std::size_t dsin;
};


struct StampedBase
{
  typedef boost::shared_ptr<StampedBase> Ptr;
  typedef boost::shared_ptr<const StampedBase> ConstPtr;

  StampedBase()
  {}

  virtual ~StampedBase()
  {}

  virtual void print(std::ostream& os) const = 0;

  virtual DataHeader& header() = 0;
  virtual const DataHeader& header() const = 0;
};

namespace internal {

template <typename T, bool has_left_shift>
struct ToStream;

template <typename T>
struct ToStream<T, false>
{
  static std::ostream& print(std::ostream& os, const T& obj)
  {
    return os << sizeof(T) << " data bytes";
  }
};

template <typename T>
struct ToStream<T, true>
{
  static std::ostream& print(std::ostream& os, const T& obj)
  {
    return os << obj;
  }
};

}

template <class DataType>
struct Stamped : public StampedBase
{
private:
  // IMPORTANT: Do not change the order (data -> header) as it is
  // important for memory alignment!

  DataType m_data;
  DataHeader m_header;

public:
  /* If we build against Eigen it is possible that the DataType depends on
   * Eigen. Then the Stamped should be aligned.
   */
#ifdef _IC_BUILDER_EIGEN_
  EIGEN_MAKE_ALIGNED_OPERATOR_NEW
#endif

  typedef boost::shared_ptr<Stamped<DataType> > Ptr;
  typedef boost::shared_ptr<const Stamped<DataType> > ConstPtr;

  Stamped()
    : m_header()
  { }

  Stamped(const DataType& data)
    : m_data(data),
      m_header()
  { }

  Stamped(const DataHeader& header)
    : m_header(header)
  { }

  Stamped(const DataType& data, const DataHeader& header)
    : m_data(data),
      m_header(header)
  { }

  inline operator DataType () const { return m_data; }

  virtual DataHeader& header() { return m_header; }
  virtual const DataHeader& header() const  { return m_header; }

  inline DataType& get() { return m_data; }
  inline const DataType& get() const { return m_data; }
  inline const DataType& cget() const { return m_data; }

  inline DataType& operator * () { return m_data; }
  inline const DataType& operator * () const { return m_data; }

  inline DataType *operator -> () { return &m_data; }
  inline const DataType *operator -> () const { return &m_data; }

  virtual void print(std::ostream& os) const
  {
    os << "[seq: " << this->m_header.sequence_number
       << ", timestamp: " << boost::posix_time::to_simple_string(this->m_header.timestamp)
       << ", DSIN: " << this->m_header.dsin
       << ", Frame: " << m_header.coordinate_system
       << "; ";
#if (BOOST_VERSION >= 104800)
    internal::ToStream<DataType, boost::has_left_shift<std::ostream, DataType>::value>::print(os, m_data);
#else
    // Boost versions prior to 1.48 do not have the has_left_shift
    // type trait.
    internal::ToStream<DataType, false>::print(os, m_data);
#endif
    os << "]";
  }
};

ICL_CORE_IMPORT_EXPORT std::ostream& operator << (std::ostream& os, StampedBase const& stamped);

}

#endif