Duration.hpp

 
//
// TGUI - Texus' Graphical User Interface
// Copyright (C) 2012-2022 Bruno Van de Velde (vdv_b@tgui.eu)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it freely,
// subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented;
//    you must not claim that you wrote the original software.
//    If you use this software in a product, an acknowledgment
//    in the product documentation would be appreciated but is not required.
//
// 2. Altered source versions must be plainly marked as such,
//    and must not be misrepresented as being the original software.
//
// 3. This notice may not be removed or altered from any source distribution.
//
 
 
#ifndef TGUI_DURATION_HPP
#define TGUI_DURATION_HPP
 
#include <TGUI/Config.hpp>
#include <cstdint>
#include <chrono>
 
#if TGUI_HAS_BACKEND_SFML
    #include <SFML/System/Time.hpp>
#endif
 
 
namespace tgui
{
    class Duration
    {
    public:
 
        TGUI_CONSTEXPR Duration() :
            m_duration{std::chrono::nanoseconds::zero()}
        {
        }
 
 
        template <typename Rep, typename Period>
        TGUI_CONSTEXPR Duration(std::chrono::duration<Rep, Period> duration) :
            m_duration{std::chrono::duration_cast<std::chrono::nanoseconds>(duration)}
        {
        }
 
 
        TGUI_CONSTEXPR Duration(int milliseconds) :
            Duration{std::chrono::milliseconds(milliseconds)}
        {
        }
 
 
#if TGUI_HAS_BACKEND_SFML
        Duration(sf::Time duration) :
            m_duration{std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::microseconds(duration.asMicroseconds()))}
        {
        }
#endif
 
        TGUI_CONSTEXPR float asSeconds() const
        {
            return m_duration.count() / 1000000000.f;
        }
 
 
        TGUI_CONSTEXPR operator std::chrono::nanoseconds() const
        {
            return m_duration;
        }
 
 
        template <typename Rep, typename Period>
        TGUI_CONSTEXPR operator std::chrono::duration<Rep, Period>() const
        {
            return std::chrono::duration_cast<std::chrono::duration<Rep, Period>>(m_duration);
        }
 
#if TGUI_HAS_BACKEND_SFML
        operator sf::Time() const
        {
            return sf::microseconds(m_duration.count() / 1000);
        }
#endif
 
    private:
 
        std::chrono::nanoseconds m_duration;
    };
 
 
    TGUI_CONSTEXPR bool operator==(const Duration& lhs, const Duration& rhs)
    {
        return std::chrono::nanoseconds(lhs) == std::chrono::nanoseconds(rhs);
    }
 
    TGUI_CONSTEXPR bool operator!=(const Duration& lhs, const Duration& rhs)
    {
        return std::chrono::nanoseconds(lhs) != std::chrono::nanoseconds(rhs);
    }
 
    TGUI_CONSTEXPR bool operator>(const Duration& lhs, const Duration& rhs)
    {
        return std::chrono::nanoseconds(lhs) > std::chrono::nanoseconds(rhs);
    }
 
    TGUI_CONSTEXPR bool operator>=(const Duration& lhs, const Duration& rhs)
    {
        return std::chrono::nanoseconds(lhs) >= std::chrono::nanoseconds(rhs);
    }
 
    TGUI_CONSTEXPR bool operator<(const Duration& lhs, const Duration& rhs)
    {
        return std::chrono::nanoseconds(lhs) < std::chrono::nanoseconds(rhs);
    }
 
    TGUI_CONSTEXPR bool operator<=(const Duration& lhs, const Duration& rhs)
    {
        return std::chrono::nanoseconds(lhs) <= std::chrono::nanoseconds(rhs);
    }
 
 
    TGUI_CONSTEXPR Duration operator+(const Duration& lhs, const Duration& rhs)
    {
        return {std::chrono::nanoseconds(lhs) + std::chrono::nanoseconds(rhs)};
    }
 
    TGUI_CONSTEXPR Duration operator-(const Duration& lhs, const Duration& rhs)
    {
        return {std::chrono::nanoseconds(lhs) - std::chrono::nanoseconds(rhs)};
    }
 
    template <typename T, typename = typename std::enable_if<std::is_arithmetic<T>::value, T>::type>
    TGUI_CONSTEXPR Duration operator*(const Duration& lhs, T rhs)
    {
        return {std::chrono::nanoseconds(lhs) * rhs};
    }
 
    template <typename T, typename = typename std::enable_if<std::is_arithmetic<T>::value, T>::type>
    TGUI_CONSTEXPR Duration operator*(T lhs, const Duration& rhs)
    {
        return {lhs * std::chrono::nanoseconds(rhs)};
    }
 
    template <typename T, typename = typename std::enable_if<std::is_arithmetic<T>::value, T>::type>
    TGUI_CONSTEXPR Duration operator/(const Duration& lhs, T rhs)
    {
        return {std::chrono::nanoseconds(lhs) / rhs};
    }
 
    TGUI_CONSTEXPR float operator/(const Duration& lhs, const Duration& rhs)
    {
        return lhs.asSeconds() / rhs.asSeconds();
    }
 
    template <typename T, typename = typename std::enable_if<std::is_arithmetic<T>::value, T>::type>
    TGUI_CONSTEXPR Duration operator%(const Duration& lhs, T rhs)
    {
        return {std::chrono::nanoseconds(lhs) % rhs};
    }
 
    TGUI_CONSTEXPR Duration operator%(const Duration& lhs, const Duration& rhs)
    {
        return {std::chrono::nanoseconds(lhs) % std::chrono::nanoseconds(rhs)};
    }
 
 
    TGUI_CONSTEXPR Duration& operator+=(Duration& lhs, const Duration& rhs)
    {
        return lhs = lhs + rhs;
    }
 
    TGUI_CONSTEXPR Duration& operator-=(Duration& lhs, const Duration& rhs)
    {
 
        return lhs = lhs - rhs;
    }
 
    template <typename T, typename = typename std::enable_if<std::is_arithmetic<T>::value, T>::type>
    TGUI_CONSTEXPR Duration& operator*=(Duration& lhs, T rhs)
    {
        return lhs = lhs * rhs;
    }
 
    template <typename T, typename = typename std::enable_if<std::is_arithmetic<T>::value, T>::type>
    TGUI_CONSTEXPR Duration& operator/=(Duration& lhs, T rhs)
    {
        return lhs = lhs / rhs;
    }
 
    template <typename T, typename = typename std::enable_if<std::is_arithmetic<T>::value, T>::type>
    TGUI_CONSTEXPR Duration& operator%=(Duration& lhs, T rhs)
    {
        return lhs = lhs % rhs;
    }
 
    TGUI_CONSTEXPR Duration& operator%=(Duration& lhs, const Duration& rhs)
    {
        return lhs = lhs % rhs;
    }
 
}
 
 
#endif // TGUI_DURATION_HPP