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
{
 
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 std::chrono::duration_cast<Nanoseconds>(this->ToMicroseconds());
}
 
inline Microseconds Duration::ToMicroseconds()const
{
    return Microseconds(this->GetMicroseconds());
}
 
inline Milliseconds Duration::ToMilliseconds()const
{
    return std::chrono::duration_cast<Milliseconds>(this->ToMicroseconds());
}
 
inline Seconds Duration::ToSeconds()const
{
    return std::chrono::duration_cast<Seconds>(this->ToMicroseconds());
}
 
inline Minutes Duration::ToMinutes()const
{
    return std::chrono::duration_cast<Minutes>(this->ToMicroseconds());
}
 
inline Hours Duration::ToHours()const
{
    return std::chrono::duration_cast<Hours>(this->ToMicroseconds());
}
 
inline Duration::Ticks Duration::ToTicks()const
{
    std::chrono::microseconds microSeconds(this->GetMicroseconds());
    return std::chrono::duration_cast<Ticks>(this->ToMicroseconds());
}
 
std::ostream& operator<<(std::ostream& os, const Duration& value);
std::ostream& operator<<(std::ostream& os, const Duration::Ticks& value);
 
}}}} // end of namesapce Arp::System::Commons::Chrono