builds/digitalwerk/solutions/adtf_content/adtf_base/adtf_core/src/libraries/base/include/adtfbase/chrono.h

Go to the documentation of this file.

 
#pragma once
#include <adtf_utils.h>
#include <chrono>
#include <iostream>
 
#include "adtf_base_type_traits.h"
 
namespace adtf
{
namespace base
{
namespace flash
{
 
struct tNanoSeconds
{
    int64_t nCount;
 
    tNanoSeconds():
        nCount(0)
    {
    }
 
    tNanoSeconds(const tNanoSeconds&) = default;
    tNanoSeconds(tNanoSeconds&&) = default;
 
    tNanoSeconds& operator=(const tNanoSeconds&) = default;
    tNanoSeconds& operator=(tNanoSeconds&&) = default;
 
    explicit tNanoSeconds(int64_t nCount):
        nCount(nCount)
    {
    }
 
    template<typename Representation, typename Period>
    inline tNanoSeconds(const std::chrono::duration<Representation, Period>& oDuration):
            nCount(std::chrono::duration_cast<std::chrono::nanoseconds>(oDuration).count())
    {
    }
 
    tNanoSeconds& operator+=(const tNanoSeconds& tmDuration)
    {
        nCount += tmDuration.nCount;
        return *this;
    }
 
    tNanoSeconds& operator-=(const tNanoSeconds& tmDuration)
    {
        nCount -= tmDuration.nCount;
        return *this;
    }
 
    tNanoSeconds& operator*=(const int64_t& nFactor)
    {
        nCount *= nFactor;
        return *this;
    }
 
    tNanoSeconds& operator/=(const int64_t& nDivisor)
    {
        nCount /= nDivisor;
        return *this;
    }
 
    tNanoSeconds& operator%=(const int64_t& nDivisor)
    {
        nCount %= nDivisor;
        return *this;
    }
 
    inline operator std::chrono::nanoseconds() const
    {
        return std::chrono::nanoseconds(nCount);
    }
};
 
inline bool operator<(const tNanoSeconds& tmA, const tNanoSeconds& tmB)
{
    return tmA.nCount < tmB.nCount;
}
 
inline bool operator>(const tNanoSeconds& tmA, const tNanoSeconds& tmB)
{
    return tmA.nCount > tmB.nCount;
}
 
inline bool operator<=(const tNanoSeconds& tmA, const tNanoSeconds& tmB)
{
    return tmA.nCount <= tmB.nCount;
}
 
inline bool operator>=(const tNanoSeconds& tmA, const tNanoSeconds& tmB)
{
    return tmA.nCount >= tmB.nCount;
}
 
inline bool operator==(const tNanoSeconds& tmA, const tNanoSeconds& tmB)
{
    return tmA.nCount == tmB.nCount;
}
 
inline bool operator!=(const tNanoSeconds& tmA, const tNanoSeconds& tmB)
{
    return tmA.nCount != tmB.nCount;
}
 
inline tNanoSeconds operator+(const tNanoSeconds& tmA, const tNanoSeconds& tmB)
{
    return tNanoSeconds{tmA.nCount + tmB.nCount};
}
 
inline tNanoSeconds operator-(const tNanoSeconds& tmA, const tNanoSeconds& tmB)
{
    return tNanoSeconds{tmA.nCount - tmB.nCount};
}
 
inline tNanoSeconds operator*(const tNanoSeconds& tmDuration, const int64_t& nFactor)
{
    return tNanoSeconds{tmDuration.nCount * nFactor};
}
 
inline tNanoSeconds operator*(const int64_t& nFactor, const tNanoSeconds& tmDuration)
{
    return tNanoSeconds{nFactor * tmDuration.nCount};
}
 
inline tNanoSeconds operator/(const tNanoSeconds& tmDuration, const int64_t& tmB)
{
    return tNanoSeconds{tmDuration.nCount / tmB};
}
 
inline int64_t operator/(const tNanoSeconds& tmA, const tNanoSeconds& tmB)
{
    return tmA.nCount / tmB.nCount;
}
 
inline std::ostream& operator<<(std::ostream& output, const tNanoSeconds& tm)
{
    output << tm.nCount;
    return output;
}
 
template <typename DestinationTimeStamp, typename SourceTimeStamp>
DestinationTimeStamp duration_cast(const SourceTimeStamp& /*tmSource*/)
{
    static_assert(penguin::detail::always_false<DestinationTimeStamp>, "unsupported duration cast");
    return DestinationTimeStamp();
}
 
template <>
inline tTimeStamp duration_cast(const tNanoSeconds& tmSource)
{
    return tmSource.nCount / 1000;
}
 
template <>
inline tNanoSeconds duration_cast(const tTimeStamp& tmSource)
{
    return tNanoSeconds{tmSource * 1000};
}
 
template <>
inline std::chrono::nanoseconds duration_cast(const tNanoSeconds& tmSource)
{
    return tmSource;
}
 
template <>
inline tNanoSeconds duration_cast(const std::chrono::nanoseconds& tmSource)
{
    return tmSource;
}
 
template <>
inline tTimeStamp duration_cast(const std::chrono::nanoseconds& tmSource)
{
    return tmSource.count() / 1000;
}
 
} // namespace flash
 
using flash::tNanoSeconds;
using flash::duration_cast;
 
} // namespace base
} // namespace adtf