Time_t.hpp

// Copyright 2024 Proyectos y Sistemas de Mantenimiento SL (eProsima).
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
#ifndef FASTDDS_DDS_CORE__TIME_T_HPP
#define FASTDDS_DDS_CORE__TIME_T_HPP
 
#include <fastdds/fastdds_dll.hpp>
 
#include <cmath>
#include <cstdint>
#include <iostream>
 
namespace eprosima {
namespace fastdds {
namespace dds {
 
struct FASTDDS_EXPORTED_API Time_t
{
    static constexpr int32_t INFINITE_SECONDS = 0x7fffffff;
    static constexpr uint32_t INFINITE_NANOSECONDS = 0xffffffffu;
 
    int32_t seconds;
    uint32_t nanosec;
 
    Time_t();
 
    Time_t(
            int32_t sec,
            uint32_t nsec);
 
    Time_t(
            long double sec);
 
    void fraction(
            uint32_t frac);
 
    uint32_t fraction() const;
 
    int64_t to_ns() const;
 
    inline bool is_infinite() const noexcept
    {
        return is_infinite(*this);
    }
 
    static void now(
            Time_t& ret);
 
    static inline constexpr bool is_infinite(
            const Time_t& t) noexcept
    {
        return (INFINITE_SECONDS == t.seconds) || (INFINITE_NANOSECONDS == t.nanosec);
    }
 
};
 
using Duration_t = Time_t;
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC
 
static inline bool operator ==(
        const Time_t& t1,
        const Time_t& t2)
{
    if (t1.seconds != t2.seconds)
    {
        return false;
    }
    if (t1.nanosec != t2.nanosec)
    {
        return false;
    }
    return true;
}
 
static inline bool operator !=(
        const Time_t& t1,
        const Time_t& t2)
{
    if (t1.seconds != t2.seconds)
    {
        return true;
    }
    if (t1.nanosec != t2.nanosec)
    {
        return true;
    }
    return false;
}
 
static inline bool operator <(
        const Time_t& t1,
        const Time_t& t2)
{
    if (t1.seconds < t2.seconds)
    {
        return true;
    }
    else if (t1.seconds > t2.seconds)
    {
        return false;
    }
    else
    {
        if (t1.nanosec < t2.nanosec)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
}
 
static inline bool operator >(
        const Time_t& t1,
        const Time_t& t2)
{
    if (t1.seconds > t2.seconds)
    {
        return true;
    }
    else if (t1.seconds < t2.seconds)
    {
        return false;
    }
    else
    {
        if (t1.nanosec > t2.nanosec)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
}
 
static inline bool operator <=(
        const Time_t& t1,
        const Time_t& t2)
{
    if (t1.seconds < t2.seconds)
    {
        return true;
    }
    else if (t1.seconds > t2.seconds)
    {
        return false;
    }
    else
    {
        if (t1.nanosec <= t2.nanosec)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
}
 
static inline bool operator >=(
        const Time_t& t1,
        const Time_t& t2)
{
    if (t1.seconds > t2.seconds)
    {
        return true;
    }
    else if (t1.seconds < t2.seconds)
    {
        return false;
    }
    else
    {
        if (t1.nanosec >= t2.nanosec)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
}
 
inline std::ostream& operator <<(
        std::ostream& output,
        const Time_t& t)
{
    long double t_aux = t.seconds + (((long double)t.nanosec) / 1000000000ULL);
    return output << t_aux;
}
 
static inline Time_t operator +(
        const Time_t& ta,
        const Time_t& tb)
{
    Time_t result(ta.seconds + tb.seconds, ta.nanosec + tb.nanosec);
    if (result.nanosec < ta.nanosec) // Overflow is detected by any of them
    {
        ++result.seconds;
    }
    return result;
}
 
static inline Time_t operator -(
        const Time_t& ta,
        const Time_t& tb)
{
    Time_t result(ta.seconds - tb.seconds, ta.nanosec - tb.nanosec);
    if (result.nanosec > ta.nanosec) // Overflow is detected by ta
    {
        --result.seconds;
    }
    return result;
}
 
#endif // ifndef DOXYGEN_SHOULD_SKIP_THIS_PUBLIC
 
const Time_t c_TimeInfinite{Time_t::INFINITE_SECONDS, Time_t::INFINITE_NANOSECONDS};
const Time_t c_TimeZero{0, 0};
const Time_t c_TimeInvalid{-1, Time_t::INFINITE_NANOSECONDS};
 
} // namespace dds
} // namespace fastdds
} // namespace eprosima
 
#endif // FASTDDS_DDS_CORE__TIME_T_HPP