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_WINDOW_BACKEND_SFML
 #include <SFML/System/Time.hpp>
#endif
 
 
namespace tgui
{
 class Duration
 {
 public:
 
 constexpr Duration() :
 m_duration{std::chrono::nanoseconds::zero()}
 {
 }
 
 
 template <typename Rep, typename Period>
 constexpr Duration(std::chrono::duration<Rep, Period> duration) :
 m_duration{std::chrono::duration_cast<std::chrono::nanoseconds>(duration)}
 {
 }
 
 
 constexpr Duration(int milliseconds) :
 Duration{std::chrono::milliseconds(milliseconds)}
 {
 }
 
 
#if TGUI_HAS_WINDOW_BACKEND_SFML
 Duration(sf::Time duration) :
 m_duration{std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::microseconds(duration.asMicroseconds()))}
 {
 }
#endif
 
 constexpr float asSeconds() const
 {
 return static_cast<float>(static_cast<double>(m_duration.count()) / 1000000000.0);
 }
 
 
 constexpr operator std::chrono::nanoseconds() const
 {
 return m_duration;
 }
 
 
 template <typename Rep, typename Period>
 constexpr operator std::chrono::duration<Rep, Period>() const
 {
 return std::chrono::duration_cast<std::chrono::duration<Rep, Period>>(m_duration);
 }
 
#if TGUI_HAS_WINDOW_BACKEND_SFML
 operator sf::Time() const
 {
 return sf::microseconds(m_duration.count() / 1000);
 }
#endif
 
 private:
 
 std::chrono::nanoseconds m_duration;
 };
 
 
 constexpr bool operator==(const Duration& lhs, const Duration& rhs)
 {
 return std::chrono::nanoseconds(lhs) == std::chrono::nanoseconds(rhs);
 }
 
 constexpr bool operator!=(const Duration& lhs, const Duration& rhs)
 {
 return std::chrono::nanoseconds(lhs) != std::chrono::nanoseconds(rhs);
 }
 
 constexpr bool operator>(const Duration& lhs, const Duration& rhs)
 {
 return std::chrono::nanoseconds(lhs) > std::chrono::nanoseconds(rhs);
 }
 
 constexpr bool operator>=(const Duration& lhs, const Duration& rhs)
 {
 return std::chrono::nanoseconds(lhs) >= std::chrono::nanoseconds(rhs);
 }
 
 constexpr bool operator<(const Duration& lhs, const Duration& rhs)
 {
 return std::chrono::nanoseconds(lhs) < std::chrono::nanoseconds(rhs);
 }
 
 constexpr bool operator<=(const Duration& lhs, const Duration& rhs)
 {
 return std::chrono::nanoseconds(lhs) <= std::chrono::nanoseconds(rhs);
 }
 
 
 constexpr Duration operator+(const Duration& lhs, const Duration& rhs)
 {
 return {std::chrono::nanoseconds(lhs) + std::chrono::nanoseconds(rhs)};
 }
 
 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>
 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>
 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>
 constexpr Duration operator/(const Duration& lhs, T rhs)
 {
 return {std::chrono::nanoseconds(lhs) / rhs};
 }
 
 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>
 constexpr Duration operator%(const Duration& lhs, T rhs)
 {
 return {std::chrono::nanoseconds(lhs) % rhs};
 }
 
 constexpr Duration operator%(const Duration& lhs, const Duration& rhs)
 {
 return {std::chrono::nanoseconds(lhs) % std::chrono::nanoseconds(rhs)};
 }
 
 
 constexpr Duration& operator+=(Duration& lhs, const Duration& rhs)
 {
 return lhs = lhs + rhs;
 }
 
 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>
 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>
 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>
 constexpr Duration& operator%=(Duration& lhs, T rhs)
 {
 return lhs = lhs % rhs;
 }
 
 constexpr Duration& operator%=(Duration& lhs, const Duration& rhs)
 {
 return lhs = lhs % rhs;
 }
 
}
 
 
#endif // TGUI_DURATION_HPP