TimeHumanReadable.h

Go to the documentation of this file.

/*
 * Copyright (C) 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_TIMEHUMANREADABLE_H_
#define _MIRA_TIMEHUMANREADABLE_H_

#include <utils/Time.h>
#include <serialization/ReflectControlFlags.h>
#include <serialization/Accessor.h>

namespace mira {


namespace HumanReadableSerialization {

template<bool AsString = true>
class Date : public mira::Date {
public:
    typedef mira::Date Base;
public:
#if !defined(DATE_TIME_NO_DEFAULT_CONSTRUCTOR)
    Date() {}
#endif
    Date(const Base& date) : Base(date) {}
    using mira::Date::Date; // inherit all constructors
};

} // namespace HumanReadableSerialization

using DateSerializedAsIsoString = HumanReadableSerialization::Date<true>;

using DateSerializedAsYMD = HumanReadableSerialization::Date<false>;

MIRA_SPLIT_REFLECT(DateSerializedAsIsoString)
MIRA_SPLIT_REFLECT(DateSerializedAsYMD)

template<typename Reflector>
void reflectRead(Reflector& r, DateSerializedAsIsoString& date)
{
    std::string s = to_iso_extended_string(date);
    r.delegate(s);
}

template<typename Reflector>
void reflectRead(Reflector& r, DateSerializedAsYMD& date)
{
    DateSerializedAsYMD::ymd_type ymd = date.year_month_day();
    int y = ymd.year;
    int m = ymd.month;
    int d = ymd.day;
    r.member("Year",  y, "year",  REFLECT_CTRLFLAG_MEMBER_AS_ROPROPERTY);
    r.member("Month", m, "month", REFLECT_CTRLFLAG_MEMBER_AS_ROPROPERTY);
    r.member("Day",   d, "day",   REFLECT_CTRLFLAG_MEMBER_AS_ROPROPERTY);

    r.roproperty("Weekday", boost::lexical_cast<std::string>(date.day_of_week()),
                 "Day of week");
}

template<typename Reflector>
void reflectWrite(Reflector& r, DateSerializedAsIsoString& date)
{
    std::string s;
    r.delegate(s);
    date = boost::gregorian::from_string(s);
}

template<typename Reflector>
void reflectWrite(Reflector& r, DateSerializedAsYMD& date)
{
    int y, m, d;
    r.member("Year",  y, "");
    r.member("Month", m, "");
    r.member("Day",   d, "");

    date = DateSerializedAsYMD::Base(y, m, d);
}


namespace HumanReadableSerialization {

template<bool AsString = true>
class Duration : public mira::Duration {
public:
    typedef mira::Duration Base;
#if !defined(DATE_TIME_NO_DEFAULT_CONSTRUCTOR)
    Duration() {}
#endif
    Duration(const Base& date) : Base(date) {}
    using mira::Duration::Duration; // inherit all constructors

    MIRA_SPLIT_REFLECT_MEMBER

    template<typename Reflector>
    void reflectRead(Reflector& r)
    {
        if constexpr (AsString) {
            std::string s = to_simple_string(*this);
            r.delegate(s);
        }
        else {
            int h = hours();
            int m = minutes();
            int s = seconds();
            int ms = milliseconds();
            int us = microseconds();
            r.member("Hours",        h,  "Hours 0..23",   REFLECT_CTRLFLAG_MEMBER_AS_ROPROPERTY);
            r.member("Minutes",      m,  "Minutes 0..59", REFLECT_CTRLFLAG_MEMBER_AS_ROPROPERTY);
            r.member("Seconds",      s,  "Seconds 0..59", REFLECT_CTRLFLAG_MEMBER_AS_ROPROPERTY);
            r.member("MilliSeconds", ms, "Milliseconds 0..999 (optional, default=0)",
                     REFLECT_CTRLFLAG_MEMBER_AS_ROPROPERTY);
            r.member("MicroSeconds", us, "Microseconds 0..999 (optional, default=0)",
                     REFLECT_CTRLFLAG_MEMBER_AS_ROPROPERTY);
        }
    }

    template<typename Reflector>
    void reflectWrite(Reflector& r)
    {
        if constexpr (AsString) {
            std::string s;
            r.delegate(s);
            *this = Base(boost::posix_time::duration_from_string(s));
        } else {
            int64 h, m, s, ms, us;
            r.member("Hours",        h, "Hours 0..23");
            r.member("Minutes",      m, "Minutes 0..59");
            r.member("Seconds",      s, "Seconds 0..59");
            r.member("MilliSeconds", ms, "Milliseconds 0..999 (optional, default=0)", 0);
            r.member("MicroSeconds", us, "Microseconds 0..999 (optional, default=0)", 0);

            *this = Base::microseconds(1000ll*(1000ll*(60ll*(60ll*h+m)+s)+ms)+us);
        }
    }
};

} // namespace HumanReadableSerialization

using DurationSerializedAsIsoString = HumanReadableSerialization::Duration<true>;

using DurationSerializedAsHMS = HumanReadableSerialization::Duration<false>;

namespace HumanReadableSerialization {

template<bool AsString = true>
class Time : public mira::Time {
public:
    typedef mira::Time Base;
#if !defined(DATE_TIME_NO_DEFAULT_CONSTRUCTOR)
    Time() {}
#endif
    Time(const Base& date) : Base(date) {}
    using mira::Time::Time; // inherit all constructors

    MIRA_SPLIT_REFLECT_MEMBER

    template<typename Reflector>
    void reflectRead(Reflector& r)
    {
        if constexpr (AsString) {
            std::string s = to_iso_extended_string(*this);
            r.delegate(s);
        } else {
            DateSerializedAsYMD dateHR(date());
            mira::reflectRead(r, dateHR);
            DurationSerializedAsHMS(time_of_day()).reflectRead(r);
        }
    }

    template<typename Reflector>
    void reflectWrite(Reflector& r)
    {
        if constexpr (AsString) {
            std::string s;
            r.delegate(s);
#if BOOST_VERSION >= 107300
            *this = Base(boost::posix_time::from_iso_extended_string(s));
#else
            *this = Base(boost::date_time::parse_delimited_time<Base>(s, 'T'));
#endif
        } else {
            DateSerializedAsYMD date;
            mira::reflectWrite(r, date);

            DurationSerializedAsHMS timeOfDay;
            timeOfDay.reflectWrite(r);

            *this = Base(date, timeOfDay);
        }
    }
};

} // namespace HumanReadableSerialization

using TimeSerializedAsIsoString = HumanReadableSerialization::Time<true>;

using TimeSerializedAsYMDHMS = HumanReadableSerialization::Time<false>;


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

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

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


struct TimeTypesSerializedAsElements { explicit TimeTypesSerializedAsElements() = default; };

Getter<DateSerializedAsIsoString> humanReadableGetter(const Date& date);

Setter<DateSerializedAsIsoString> humanReadableSetter(Date& date);

Accessor<Getter<DateSerializedAsIsoString>, Setter<DateSerializedAsIsoString>>
humanReadableAccessor(Date& date);

Getter<DateSerializedAsYMD> humanReadableGetter(const Date& date, TimeTypesSerializedAsElements);

Setter<DateSerializedAsYMD> humanReadableSetter(Date& date, TimeTypesSerializedAsElements);

Accessor<Getter<DateSerializedAsYMD>, Setter<DateSerializedAsYMD>>
humanReadableAccessor(Date& date, TimeTypesSerializedAsElements);

Getter<DurationSerializedAsIsoString> humanReadableGetter(const Duration& duration);

Setter<DurationSerializedAsIsoString> humanReadableSetter(Duration& duration);

Accessor<Getter<DurationSerializedAsIsoString>, Setter<DurationSerializedAsIsoString>>
humanReadableAccessor(Duration& duration);

Getter<DurationSerializedAsHMS> humanReadableGetter(const Duration& duration, TimeTypesSerializedAsElements);

Setter<DurationSerializedAsHMS> humanReadableSetter(Duration& duration, TimeTypesSerializedAsElements);

Accessor<Getter<DurationSerializedAsHMS>, Setter<DurationSerializedAsHMS>>
humanReadableAccessor(Duration& duration, TimeTypesSerializedAsElements);

Getter<TimeSerializedAsIsoString> humanReadableGetter(const Time& time);

Setter<TimeSerializedAsIsoString> humanReadableSetter(Time& time);

Accessor<Getter<TimeSerializedAsIsoString>, Setter<TimeSerializedAsIsoString>>
humanReadableAccessor(Time& time);

Getter<TimeSerializedAsYMDHMS> humanReadableGetter(const Time& time, TimeTypesSerializedAsElements);

Setter<TimeSerializedAsYMDHMS> humanReadableSetter(Time& time, TimeTypesSerializedAsElements);

Accessor<Getter<TimeSerializedAsYMDHMS>, Setter<TimeSerializedAsYMDHMS>>
humanReadableAccessor(Time& time, TimeTypesSerializedAsElements);


}

#endif