Duration.hpp

//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Commons/Chrono/DurationUnit.hpp"
#include <chrono>
#include <iostream>

namespace Arp { namespace System { namespace Commons { namespace Chrono
{

using namespace std::chrono;

class Duration
{
public: // typedefs
    typedef std::chrono::microseconds Ticks;

public: // construction/destruction
    Duration(int factor = 0, DurationUnit unit = DurationUnit::None);
    Duration(const Duration& arg) = default;
    Duration& operator=(const Duration& arg) = default;
    ~Duration(void) = default;

public: // static properties
    static const Ticks Tick;

public: // static operations
    static Duration Parse(const char* input);
    static bool     TryParse(const char* input, Duration& result);

public: // setter/getter operations
    int64           GetFactor(void)const;
    DurationUnit    GetUnit(void)const;
    int64           GetMicroseconds(void)const;

public: // operations
    Nanoseconds     ToNanoseconds(void)const;
    Microseconds    ToMicroseconds(void)const;
    Milliseconds    ToMilliseconds(void)const;
    Seconds         ToSeconds(void)const;
    Minutes         ToMinutes(void)const;
    Hours           ToHours(void)const;
    Ticks           ToTicks(void)const;
    String          ToString(void)const;

    void            GetDuration(Nanoseconds& value)const;
    void            GetDuration(Microseconds& value)const;
    void            GetDuration(Milliseconds& value)const;
    void            GetDuration(Seconds& value)const;
    void            GetDuration(Minutes& value)const;
    void            GetDuration(Hours& value)const;

protected: // operations

private: // static methods

private: // methods

private: // fields
    int64           factor;
    DurationUnit    unit;

private: // static fields

};

// inline methods of class Duration
inline Duration::Duration(int factorArg, DurationUnit unitArg)
    : factor(factorArg)
    , unit(unitArg)
{
}

inline int64 Duration::GetFactor()const
{
    return this->factor;
}

inline DurationUnit Duration::GetUnit()const
{
    return this->unit;
}

inline Nanoseconds Duration::ToNanoseconds()const
{
    return duration_cast<Nanoseconds>(this->ToMicroseconds());
}

inline Microseconds Duration::ToMicroseconds()const
{
    return Microseconds(this->GetMicroseconds());
}

inline Milliseconds Duration::ToMilliseconds()const
{
    return duration_cast<Milliseconds>(this->ToMicroseconds());
}

inline Seconds Duration::ToSeconds()const
{
    return duration_cast<Seconds>(this->ToMicroseconds());
}

inline Minutes Duration::ToMinutes()const
{
    return duration_cast<Minutes>(this->ToMicroseconds());
}

inline Hours Duration::ToHours()const
{
    return duration_cast<Hours>(this->ToMicroseconds());
}

inline Duration::Ticks Duration::ToTicks()const
{
    std::chrono::microseconds microSeconds(this->GetMicroseconds());
    return duration_cast<Ticks>(this->ToMicroseconds());
}

inline std::ostream& operator<<(std::ostream& os, const Duration& value)
{
    os << value.GetFactor() << Enum<DurationUnit>(value.GetUnit()).ToString();
    return os;
}

inline std::ostream& operator<<(std::ostream& os, const Duration::Ticks& value)
{
    os << value.count() << "us";
    return os;
}

}}}} // end of namesapce Arp::System::Commons::Chrono