SttclTime.h

Go to the documentation of this file.

#ifndef STTCLTIME_H_
#define STTCLTIME_H_

#ifndef STTCL_DEFAULT_TIMEDURATIONIMPL
#if defined(STTCL_POSIX_TIME)  or defined(STTCL_POSIX_IMPL)
#include "../PosixTime/SttclPosixTime.h"
#define STTCL_DEFAULT_TIMEDURATIONIMPL sttcl::internal::posix_impl::SttclPosixTimeDuration
#elif defined(STTCL_BOOST_TIME) or defined(STTCL_BOOST_IMPL)
#include "../BoostTime/SttclBoostTime.h"
#define STTCL_DEFAULT_TIMEDURATIONIMPL sttcl::internal::boost_impl::SttclBoostTimeDuration
#elif defined(STTCL_CX11_TIME) or defined(STTCL_CX11_IMPL)
#include "../C++11Time/SttclCx11Time.h"
#define STTCL_DEFAULT_TIMEDURATIONIMPL sttcl::internal::cx11_impl::SttclCx11TimeDuration
#endif

#ifndef STTCL_DEFAULT_TIMEDURATIONIMPL
#error "You need to define a default time duration implementation for sttcl"
#endif
#endif

namespace sttcl
{

template<class Implementation = STTCL_DEFAULT_TIMEDURATIONIMPL>
class TimeDuration
: public Implementation
{
public:
        typedef typename Implementation::NativeTimeDuration NativeTimeDuration;

        static const TimeDuration<Implementation> Zero;

        TimeDuration(unsigned int argHours = 0, unsigned int argMinutes = 0, unsigned int argSeconds = 0, unsigned int argMilliSeconds = 0, unsigned long argMicroSeconds = 0, unsigned long argNanoSeconds = 0)
        : Implementation(argHours,argMinutes,argSeconds,argMilliSeconds,argMicroSeconds,argNanoSeconds)
        {
        }

        TimeDuration(const TimeDuration<Implementation>& rhs)
        : Implementation(static_cast<const Implementation&>(rhs))
        {
        }
        TimeDuration(const NativeTimeDuration& nativeTimeDuration)
        : Implementation(nativeTimeDuration)
        {
        }
        ~TimeDuration()
        {
        }

        TimeDuration<Implementation>& operator=(const TimeDuration<Implementation>& rhs)
        {
                Implementation::operator=(static_cast<const Implementation&>(rhs));
                return *this;
        }

        TimeDuration<Implementation>& operator=(const NativeTimeDuration& nativeTimeDuration)
        {
                Implementation::operator=(static_cast<const Implementation&>(nativeTimeDuration));
                return *this;
        }

        bool operator==(const TimeDuration<Implementation>& rhs) const
        {
                return Implementation::operator==(static_cast<const Implementation&>(rhs));
        }
        bool operator!=(const TimeDuration<Implementation>& rhs) const
        {
                return Implementation::operator!=(static_cast<const Implementation&>(rhs));
        }
        bool operator<(const TimeDuration<Implementation>& rhs) const
        {
                return Implementation::operator<(static_cast<const Implementation&>(rhs));
        }
        bool operator<=(const TimeDuration<Implementation>& rhs) const
        {
                return Implementation::operator<=(static_cast<const Implementation&>(rhs));
        }
        bool operator>(const TimeDuration<Implementation>& rhs) const
        {
                return Implementation::operator>(static_cast<const Implementation&>(rhs));
        }
        bool operator>=(const TimeDuration<Implementation>& rhs) const
        {
                return Implementation::operator>=(static_cast<const Implementation&>(rhs));
        }

        TimeDuration<Implementation>& operator+=(const TimeDuration<Implementation>& rhs)
        {
                Implementation::operator+=(static_cast<const Implementation&>(rhs));
                return *this;
        }

        TimeDuration<Implementation>& operator-=(const TimeDuration<Implementation>& rhs)
        {
                Implementation::operator-=(static_cast<const Implementation&>(rhs));
                return *this;
        }

        TimeDuration<Implementation>& operator*=(int factor)
        {
                Implementation::operator*=(factor);
                return *this;
        }

        TimeDuration<Implementation>& operator/=(int divider)
        {
                Implementation::operator/=(divider);
                return *this;
        }

        long hours() const
        {
                return Implementation::hours();
        }
        long minutes() const
        {
                return Implementation::minutes();
        }
        long seconds() const
        {
                return Implementation::seconds();
        }
        long milliseconds() const
        {
                return Implementation::milliseconds();
        }
        long microseconds() const
        {
                return Implementation::microseconds();
        }
        long nanoseconds() const
        {
                return Implementation::nanoseconds();
        }

        void hours(int newHours)
        {
                Implementation::hours(newHours);
        }
        void minutes(int newMinutes)
        {
                Implementation::minutes(newMinutes);
        }
        void seconds(int newSeconds)
        {
                Implementation::seconds(newSeconds);
        }

        /*
        void milliseconds(int newMilliSeconds)
        {
                Implementation::milliseconds(newMilliSeconds);
        }
        */
        /*
        void microseconds(int newMicroSeconds)
        {
                Implementation::microseconds(newMicroSeconds);
        }
        */
        /*
        void nanoseconds(long newNanoSeconds)
        {
                Implementation::nanoseconds(newNanoSeconds);
        }
        */

        const NativeTimeDuration& getNativeValue() const
        {
                return Implementation::getNativeValue();
        }
};


}

template<class Implementation>
static sttcl::TimeDuration<Implementation> operator+(const sttcl::TimeDuration<Implementation>& op1, const sttcl::TimeDuration<Implementation>& op2)
{
        sttcl::TimeDuration<Implementation> result(op1);
        return result += op2;
}

template<class Implementation>
static sttcl::TimeDuration<Implementation> operator-(const sttcl::TimeDuration<Implementation>& op1, const sttcl::TimeDuration<Implementation>& op2)
{
        sttcl::TimeDuration<Implementation> result(op1);
        return result -= op2;
}
template<class Implementation>
static sttcl::TimeDuration<Implementation> operator*(const sttcl::TimeDuration<Implementation>& op1, int op2)
{
        sttcl::TimeDuration<Implementation> result(op1);
        return result *= op2;
}
template<class Implementation>
static sttcl::TimeDuration<Implementation> operator/(const sttcl::TimeDuration<Implementation>& op1, int op2)
{
        sttcl::TimeDuration<Implementation> result(op1);
        return result /= op2;
}

template<class Implementation>
const sttcl::TimeDuration<Implementation> sttcl::TimeDuration<Implementation>::Zero = sttcl::TimeDuration<Implementation>();
#endif /* STTCLTIME_H_ */