Stamped.h

Go to the documentation of this file.

/*
 * Copyright (C) 2012 by
 *   MetraLabs GmbH (MLAB), GERMANY
 * and
 *   Neuroinformatics and Cognitive Robotics Labs (NICR) at TU Ilmenau, GERMANY
 * All rights reserved.
 *
 * Contact: info@mira-project.org
 *
 * Commercial Usage:
 *   Licensees holding valid commercial licenses may use this file in
 *   accordance with the commercial license agreement provided with the
 *   software or, alternatively, in accordance with the terms contained in
 *   a written agreement between you and MLAB or NICR.
 *
 * GNU General Public License Usage:
 *   Alternatively, this file may be used under the terms of the GNU
 *   General Public License version 3.0 as published by the Free Software
 *   Foundation and appearing in the file LICENSE.GPL3 included in the
 *   packaging of this file. Please review the following information to
 *   ensure the GNU General Public License version 3.0 requirements will be
 *   met: http://www.gnu.org/copyleft/gpl.html.
 *   Alternatively you may (at your option) use any later version of the GNU
 *   General Public License if such license has been publicly approved by
 *   MLAB and NICR (or its successors, if any).
 *
 * IN NO EVENT SHALL "MLAB" OR "NICR" BE LIABLE TO ANY PARTY FOR DIRECT,
 * INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF
 * THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF "MLAB" OR
 * "NICR" HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * "MLAB" AND "NICR" SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING,
 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
 * ON AN "AS IS" BASIS, AND "MLAB" AND "NICR" HAVE NO OBLIGATION TO
 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS OR MODIFICATIONS.
 */

#ifndef _MIRA_STAMPED_H_
#define _MIRA_STAMPED_H_

#include <serialization/adapters/boost/shared_ptr.hpp>

#include <utils/Time.h>

namespace mira {


class StampedHeader
{
public:
    StampedHeader() : sequenceID(0) {}

    StampedHeader(const Time& iTimestamp, uint32 iSequenceID = 0) :
        timestamp(iTimestamp),
        sequenceID(iSequenceID) {}

    StampedHeader(const Time& iTimestamp,
                  const std::string& iFrameID, uint32 iSequenceID = 0) :
        timestamp(iTimestamp),
        frameID(iFrameID),
        sequenceID(iSequenceID) {}

public:

    template<typename Reflector>
    void reflect(Reflector& r)
    {
        r.member("Timestamp",  timestamp, "The timestamp", Time::now());
        r.member("FrameID",    frameID,
                 "The id of the transformation frame, this data belongs to",
                 "");
        r.member("SequenceID", sequenceID, "A user defined sequence ID", 0);
    }

public:

    Time timestamp;

    std::string frameID;

    uint32 sequenceID;
};

template <typename T>
class Stamped : public StampedHeader, public T
{
public:

    typedef T value_type ;

public:

    Stamped() {}

    Stamped(const T& iData, const Time& iTimestamp, uint32 iSequenceID = 0) :
        StampedHeader(iTimestamp, iSequenceID), T(iData) {}

    Stamped(T&& iData, const Time& iTimestamp, uint32 iSequenceID = 0) :
        StampedHeader(iTimestamp, iSequenceID), T(std::move(iData)) {}

    Stamped(const T& iData, const Time& iTimestamp,
            const std::string& iFrameID, uint32 iSequenceID = 0) :
        StampedHeader(iTimestamp, iFrameID, iSequenceID), T(iData) {}

    Stamped(T&& iData, const Time& iTimestamp,
            const std::string& iFrameID, uint32 iSequenceID = 0) :
        StampedHeader(iTimestamp, iFrameID, iSequenceID), T(std::move(iData)) {}

public:

    template<typename Reflector>
    void reflect(Reflector& r)
    {
        MIRA_REFLECT_BASE(r, StampedHeader);
        r.member("Value", (T&)*this, "The value");
    }

public:

    T& value() { return *this; }

    const T& value() const { return *this; }

    T& internalValueRep() { return *this; }

    const T& internalValueRep() const { return *this; }

};


class Object; // forward declaration of mira::Object in factory/Object.h

template <typename T>
class Stamped<T*> : public StampedHeader
{
    static_assert(std::is_base_of<mira::Object,T>::value, 
                  "Pointers that are used with Stamped<T> must be of polymorphic"
                  " classes that are derived from mira::Object. Pointers to other"
                  " classes cannot be used with Stamped<T>.");
public:

    typedef T* value_type ;

public:

    Stamped() {}

    Stamped(T* iData, const Time& iTimestamp, uint32 iSequenceID = 0) :
        StampedHeader(iTimestamp, iSequenceID), mPointer(iData) {}

    Stamped(T* iData, const Time& iTimestamp, const std::string& iFrameID,
            uint32 iSequenceID = 0) :
        StampedHeader(iTimestamp, iFrameID, iSequenceID), mPointer(iData) {}

public:

    template<typename Reflector>
    void reflect(Reflector& r)
    {
        MIRA_REFLECT_BASE(r, StampedHeader);
        r.member("Value", mPointer, "The value");
    }

public:

    T* value() { return dynamic_cast<T*>(mPointer.get()); }

    const T* value() const { return dynamic_cast<T*>(mPointer.get()); }

    operator const T*() const { return value(); }

    operator T*() { return value(); }

    T* operator=(T* iValue) {mPointer.reset(iValue);  return iValue; }

    boost::shared_ptr<Object>& internalValueRep() { return mPointer; }

    const boost::shared_ptr<Object>& internalValueRep() const { return mPointer; }

public:

    // Note: the following casts look dangerous, however, they're safe since
    // all Stamped<T*> store a pointer to Object* and hence all of them are
    // equal. Moreover, our accessor methods above take care of type safety
    // using the dynamic_casts when accessing the underlying data.

    template <typename U>
    operator const Stamped<U*>& () const {
        static_assert(sizeof(Stamped<U*>)==sizeof(Stamped<T*>), 
                      "The following is safe as long as all Stamped<T*> have the same size");
        return reinterpret_cast<const Stamped<U*>&>(*this);
    }

    template <typename U>
    operator Stamped<U*>& () {
        static_assert(sizeof(Stamped<U*>)==sizeof(Stamped<T*>), 
                      "The following is safe as long as all Stamped<T*> have the same size");
        return reinterpret_cast<Stamped<U*>&>(*this);
    }

private:

    boost::shared_ptr<Object> mPointer;
};


template <typename T>
class StampedPrimitive : public StampedHeader
{
public:

    typedef T value_type ;

public:

    StampedPrimitive() {}

    StampedPrimitive(const T& iData, const Time& iTimestamp,
                     uint32 iSequenceID = 0) :
        StampedHeader(iTimestamp, iSequenceID), mValue(iData) {}

    StampedPrimitive(const T& iData, const Time& iTimestamp,
                     const std::string& iFrameID, uint32 iSequenceID = 0) :
        StampedHeader(iTimestamp, iFrameID, iSequenceID), mValue(iData) {}

public:

    template<typename Reflector>
    void reflect(Reflector& r)
    {
        MIRA_REFLECT_BASE(r, StampedHeader);
        r.member("Value", mValue, "The value");
    }

public:

    T& value() { return mValue; }

    const T& value() const { return mValue; }

    operator const T&() const { return mValue; }

    operator T&() { return mValue; }

    const T& operator=(const T& iValue) { return mValue = iValue; }

    T& internalValueRep() { return mValue; }

    const T& internalValueRep() const { return mValue; }

private:

    T mValue;
};


#define MIRA_DECLARE_STAMPED_PRIMITIVE_SPECIALIZATION(T)                      \
template <>                                                                  \
class Stamped<T> : public StampedPrimitive<T>                                \
{                                                                            \
public:                                                                      \
    Stamped() {}                                                             \
    Stamped(const T& iData, const Time& iTimestamp, uint32 iSequenceID=0) :  \
        StampedPrimitive<T>(iData, iTimestamp,iSequenceID) {}                \
    Stamped(const T& iData, const Time& iTimestamp,                          \
            const std::string& iFrameID, uint32 iSequenceID=0) :             \
            StampedPrimitive<T>(iData, iTimestamp, iFrameID, iSequenceID) {} \
};

MIRA_DECLARE_STAMPED_PRIMITIVE_SPECIALIZATION(bool)
MIRA_DECLARE_STAMPED_PRIMITIVE_SPECIALIZATION(uint8)
MIRA_DECLARE_STAMPED_PRIMITIVE_SPECIALIZATION(int8)
MIRA_DECLARE_STAMPED_PRIMITIVE_SPECIALIZATION(uint16)
MIRA_DECLARE_STAMPED_PRIMITIVE_SPECIALIZATION(int16)
MIRA_DECLARE_STAMPED_PRIMITIVE_SPECIALIZATION(uint32)
MIRA_DECLARE_STAMPED_PRIMITIVE_SPECIALIZATION(int32)
MIRA_DECLARE_STAMPED_PRIMITIVE_SPECIALIZATION(uint64)
MIRA_DECLARE_STAMPED_PRIMITIVE_SPECIALIZATION(int64)
MIRA_DECLARE_STAMPED_PRIMITIVE_SPECIALIZATION(char)
MIRA_DECLARE_STAMPED_PRIMITIVE_SPECIALIZATION(float)
MIRA_DECLARE_STAMPED_PRIMITIVE_SPECIALIZATION(double)
MIRA_DECLARE_STAMPED_PRIMITIVE_SPECIALIZATION(std::string)


template <typename T>
Stamped<typename std::decay<T>::type> makeStamped(T&& value, const Time& timestamp = Time::now(),
                                                  const std::string& frameID = std::string(),
                                                  uint32 sequenceID = 0)
{
    return Stamped<typename std::decay<T>::type>(std::forward<T>(value), timestamp, frameID, sequenceID);
}

template <typename T>
StampedHeader& stampedHeader(Stamped<T>& data) {
    return data;
}

template <typename T>
const StampedHeader& stampedHeader(const Stamped<T>& data) {
    return data;
}



}

#endif