Time.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_TIME_H_
#define _MIRA_TIME_H_

#ifndef Q_MOC_RUN
#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/date_time/local_time/local_time.hpp>
#include <boost/date_time/c_local_time_adjustor.hpp>
#endif

#include <platform/Types.h>
#include <serialization/SplitReflect.h>
#include <serialization/IsTransparentSerializable.h>

#include <utils/IsCheapToCopy.h>

namespace mira {


typedef boost::gregorian::date Date;
typedef boost::gregorian::date_duration DateDuration;

using boost::date_time::Jan;
using boost::date_time::Feb;
using boost::date_time::Mar;
using boost::date_time::Apr;
using boost::date_time::May;
using boost::date_time::Jun;
using boost::date_time::Jul;
using boost::date_time::Aug;
using boost::date_time::Sep;
using boost::date_time::Oct;
using boost::date_time::Nov;
using boost::date_time::Dec;

using boost::date_time::Monday;
using boost::date_time::Tuesday;
using boost::date_time::Wednesday;
using boost::date_time::Thursday;
using boost::date_time::Friday;
using boost::date_time::Saturday;
using boost::date_time::Sunday;

class Duration : public boost::posix_time::time_duration
{
protected:

    typedef boost::posix_time::time_duration Base;

public:

    static Duration nanoseconds(int64 v) {
        Duration d;
#if defined(BOOST_DATE_TIME_HAS_NANOSECONDS)
        d.ticks_ = v;
#else
        d.ticks_ = v / 1000;
#endif
        return d;
    }

    static Duration microseconds(int64 v) {
        Duration d;
#if defined(BOOST_DATE_TIME_HAS_NANOSECONDS)
        d.ticks_ = v * 1000;
#else
        d.ticks_ = v;
#endif
        return d;
    }

    static Duration milliseconds(int64 v) {
        Duration d;
#if defined(BOOST_DATE_TIME_HAS_NANOSECONDS)
        d.ticks_ = v * 1000000;
#else
        d.ticks_ = v * 1000;
#endif
        return d;
    }

    static Duration seconds(int32 v) { return boost::posix_time::seconds(v); }

    static Duration minutes(int32 v) { return boost::posix_time::minutes(v); }

    static Duration hours(int32 v) { return boost::posix_time::hours(v); }

public:
    Duration(hour_type hour, min_type min, sec_type sec, 
             fractional_seconds_type fs=0) :
        Base(hour, min, sec, fs)
    {}

    Duration(const Base& d) :
        Base(d)
    {}

    Duration(const boost::posix_time::special_values sv) :
        Base(sv)
    {}

#if !defined(DATE_TIME_NO_DEFAULT_CONSTRUCTOR)
    Duration()
    {}
#endif // DATE_TIME_NO_DEFAULT_CONSTRUCTOR

public:

    MIRA_SPLIT_REFLECT_MEMBER

    template<typename Reflector>
    void reflectRead(Reflector& r)
    {
        int64 t = totalMilliseconds();
        r.delegate(t);
    }

    template<typename Reflector>
    void reflectWrite(Reflector& r)
    {
        int64 t;
        r.delegate(t);
        *this = Duration::milliseconds(t);
    }

public:

    static Duration negativeInfinity()
    {
        return Duration(boost::posix_time::neg_infin);
    }
    static Duration infinity()
    {
        return Duration(boost::posix_time::pos_infin);
    }
    static Duration invalid()
    {
        return Duration(boost::posix_time::not_a_date_time);
    }

    bool isValid() const
    {
        return !this->is_not_a_date_time();
    }
    bool isInfinity() const
    {
        return this->is_pos_infinity() || this->is_neg_infinity();
    }

    hour_type hours() const
    {
        return Base::hours();
    }
    min_type minutes() const
    {
        return Base::minutes();
    }
    sec_type seconds() const
    {
        return Base::seconds();
    }
    tick_type milliseconds() const
    {
        return totalMilliseconds() % 1000;
    }
    tick_type microseconds() const
    {
        return totalMicroseconds() % 1000;
    }
    tick_type nanoseconds() const
    {
        return totalNanoseconds() % 1000;
    }
    sec_type totalSeconds() const
    {
        return Base::total_seconds();
    }
    tick_type totalMilliseconds() const
    {
        return Base::total_milliseconds();
    }
    tick_type totalMicroseconds() const
    {
        return Base::total_microseconds();
    }
    tick_type totalNanoseconds() const
    {
        return Base::total_nanoseconds();
    }

public:

    Duration operator-()const
    {
        return Base::operator -();
    }
    Duration operator-(const Duration& d) const
    {
        return Base::operator-(d);
    }
    Duration operator+(const Duration& d) const
    {
        return Base::operator+(d);
    }
    Duration operator/(int divisor) const
    {
        assert(divisor != 0);
        return Base::operator/(divisor);
    }
    Duration operator/(float divisor) const
    {
        assert(divisor != 0.0f);
        Duration d;
        d.ticks_ = (int64)(ticks_.as_number() / divisor);
        return d;
    }
    float operator/(Duration other) const
    {
        return (float)totalNanoseconds() / other.totalNanoseconds();
    }
    Duration operator-=(const Duration& d)
    {
        return Base::operator-=(d);
    }
    Duration operator+=(const Duration& d)
    {
        return Base::operator+=(d);
    }
    Duration operator/=(int divisor)
    {
        assert(divisor != 0);
        return Base::operator/=(divisor);
    }
    Duration operator/=(float divisor)
    {
        assert(divisor != 0.0f);
        ticks_ = (int64)(ticks_.as_number() / divisor);
        return *this;
    }
    Duration operator*(int rhs) const
    {
        return Base::operator*(rhs);
    }
    Duration operator*(float rhs) const
    {
        Duration d;
        d.ticks_ = (int64)(ticks_.as_number() * rhs);
        return d;
    }
    Duration operator*=(int rhs)
    {
        return Base::operator*=(rhs);
    }
    Duration operator*=(float rhs)
    {
        ticks_ = (int64)(ticks_.as_number() * rhs);
        return *this;
    }
};


inline Duration abs(const Duration& duration)
{
    if ( duration.is_negative() )
        return duration.invert_sign();
    return duration;
}

class MIRA_BASE_EXPORT Time : public boost::posix_time::ptime
{
public:

    typedef boost::posix_time::ptime Base;

public:

    Time(Date d, Duration td) :
        Base(d, td)
    {}

    Time(const Base& p) :
        Base(p)
    {}
    explicit Time(Date d) :
        Base(d, Duration(0, 0, 0))
    {}

    Time(const Base::time_rep_type& rhs) :
        Base(rhs)
    {}
    Time(const boost::posix_time::special_values sv) :
        Base(sv)
    {}

#if !defined(DATE_TIME_NO_DEFAULT_CONSTRUCTOR)
    Time()
    {}
#endif // DATE_TIME_NO_DEFAULT_CONSTRUCTOR

public:

    MIRA_SPLIT_REFLECT_MEMBER

    template<typename Reflector>
    void reflectRead(Reflector& r)
    {
        int64 t = toUnixNS();
        r.delegate(t);
    }

    template<typename Reflector>
    void reflectWrite(Reflector& r)
    {
        int64 t;
        r.delegate(t);
        *this = Time::fromUnixNS(t);
    }


public:

    static Time now()
#ifdef MIRA_LINUX
    {
        return boost::posix_time::microsec_clock::universal_time();
    }
#endif
#ifdef MIRA_WINDOWS
    ; // see Time.C for implementation
#endif

    static Time eternity()
    {
        return Time(boost::posix_time::max_date_time);
    }

    static Time invalid()
    {
        return Time(boost::posix_time::not_a_date_time);
    }

    static Time unixEpoch()
    {
        static Time t1970 = Time(Date(1970,Jan,1), Duration(0,0,0));
        return t1970;
    }

    uint32 toUnixTimestamp() const
    {
        return (uint32)(*this - Time::unixEpoch()).totalSeconds();
    }

    static Time fromUnixTimestamp(uint32 seconds)
    {
        return Time::unixEpoch() + Duration::seconds(seconds);
    }

    uint64 toUnixNS() const
    {
        return (uint64)(*this - Time::unixEpoch()).totalNanoseconds();
    }

    static Time fromUnixNS(uint64 nanoseconds)
    {
        return Time::unixEpoch() + Duration::nanoseconds(nanoseconds);
    }

    Time toLocal() const
    {
        typedef boost::date_time::c_local_adjustor<Base> l;
        return l::utc_to_local(*this);
    }

    Time toTimeZone(const std::string& zone)
    {
        boost::local_time::time_zone_ptr tz(new boost::local_time::posix_time_zone(zone));
        boost::local_time::local_date_time dt(*this, tz);
        return dt.local_time();
    }

    bool isValid() const
    {
        return !this->is_not_a_date_time();
    }

public:

    Duration operator-(const Time& t) const
    {
        return Base::operator-(t);
    }
    Time operator+(const DateDuration& d) const
    {
        return Base::operator+(d);
    }
    Time operator+=(const DateDuration& d)
    {
        return Base::operator+=(d);
    }
    Time operator-(const DateDuration& d) const
    {
        return Base::operator-(d);
    }
    Time operator-=(const DateDuration& d)
    {
        return Base::operator-=(d);
    }
    Time operator+(const Duration& d) const
    {
        return Base::operator+(d);
    }
    Time operator+=(const Duration& d)
    {
        return Base::operator+=(d);
    }
    Time operator-(const Duration& d) const
    {
        return Base::operator-(d);
    }
    Time operator-=(const Duration& d)
    {
        return Base::operator-=(d);
    }
};


template<typename SerializerTag>
class IsTransparentSerializable<Time,SerializerTag> : public std::true_type {};

template<typename SerializerTag>
class IsTransparentSerializable<Duration,SerializerTag> : public std::true_type {};


template <>
class IsCheapToCopy<Time> : public std::true_type {};

template <>
class IsCheapToCopy<Duration> : public std::true_type {};


// non intrusive reflect for Date

template<typename Reflector>
void reflectRead(Reflector& r, Date& date) {
    Time t = Time(date);
    r.delegate(t);
}

template<typename Reflector>
void reflectWrite(Reflector& r, Date& date) {
     Time t;
     r.delegate(t);
     date = t.date();
}
MIRA_SPLIT_REFLECT(Date)
template<typename SerializerTag>
class IsTransparentSerializable<Date,SerializerTag> : public std::true_type {};


}

#endif