From 3c1804898a17a070c89a02ac59f474e1fee7c6fa Mon Sep 17 00:00:00 2001
From: yumetodo <yume-wikijp@live.jp>
Date: Wed, 23 Mar 2016 01:30:29 +0900
Subject: [PATCH] add arithmetic like operators to bel_c class

---
 dxlibex/basic_types/bel.hpp            | 208 +++++++++++++++++++++++--
 samples/sound_play/sound_play/main.cpp |   4 +-
 2 files changed, 197 insertions(+), 15 deletions(-)

diff --git a/dxlibex/basic_types/bel.hpp b/dxlibex/basic_types/bel.hpp
index 430678f..19f4a01 100644
--- a/dxlibex/basic_types/bel.hpp
+++ b/dxlibex/basic_types/bel.hpp
@@ -14,6 +14,7 @@ Distributed under the Boost Software License, Version 1.0.
 #include "dxlibex/type_traits/is_ratio.hpp"
 #include "dxlibex/type_traits/enable_if.hpp"
 #include <type_traits>
+#include <limits>
 namespace dxle {
 	typedef std::ratio<1, 10000> myrio;
 	namespace sound_units {
@@ -22,6 +23,14 @@ namespace dxle {
 		class bel_c;
 		template<typename To, typename T, typename Period, enable_if_t<is_bel_c<To>::value, nullptr_t> = nullptr>
 		inline DXLE_CONSTEXPR To bel_cast(const bel_c<T, Period>& o);
+
+		/// bel_c_values
+		template<typename _Rep> struct bel_c_values{
+			static DXLE_CONSTEXPR _Rep zero(){ return _Rep(0); }
+			static DXLE_CONSTEXPR _Rep max(){ return std::numeric_limits<_Rep>::max();}
+			static DXLE_CONSTEXPR _Rep min(){ return std::numeric_limits<_Rep>::lowest();	}
+		};
+
 		template<typename T, typename Period, enable_if_t<is_ratio<Period>::value, nullptr_t>>
 		class bel_c {
 		public:
@@ -53,6 +62,67 @@ namespace dxle {
 			DXLE_CONSTEXPR value_type count() const { return value_; }
 			DXLE_CONSTEXPR value_type get() const { return value_; }
 			DXLE_CONSTEXPR value_type operator*() const { return value_; }
+			DXLE_CONSTEXPR bel_c operator+() const { return *this; }
+			DXLE_CONSTEXPR bel_c operator-() const { return bel_c(-value_); }
+			bel_c& operator++()
+			{
+			  ++value_;
+			  return *this;
+			}
+
+			bel_c operator++(int) { return bel_c(value_++); }
+
+			bel_c& operator--()
+			{
+			  --value_;
+			  return *this;
+			}
+
+			bel_c operator--(int) { return bel_c(value_--); }
+
+			bel_c& operator+=(const bel_c& o)
+			{
+			  value_ += o.count();
+			  return *this;
+			}
+
+			bel_c& operator-=(const bel_c& o)
+			{
+			  value_ -= o.count();
+			  return *this;
+			}
+
+			bel_c& operator*=(const T& r)
+			{
+			  value_ *= r;
+			  return *this;
+			}
+
+			bel_c& operator/=(const T& r)
+			{
+			  value_ /= r;
+			  return *this;
+			}
+
+			// DR 934.
+			template<typename T2 = T, std::enable_if_t<!std::is_floating_point<T2>::value, std::nullptr_t> = nullptr>
+			bel_c& operator%=(const T& r)
+			{
+				value_ %= r;
+				return *this;
+			}
+
+			template<typename T2 = T, std::enable_if_t<!std::is_floating_point<T2>::value, std::nullptr_t> = nullptr>
+			bel_c& operator%=(const bel_c& o)
+			{
+				value_ %= o.count();
+				return *this;
+			}
+
+			//special values
+			static DXLE_CONSTEXPR bel_c zero() { return bel_c(bel_c_values<T>::zero()); }
+			static DXLE_CONSTEXPR bel_c min() { return bel_c(bel_c_values<T>::min()); }
+			static DXLE_CONSTEXPR bel_c max() { return bel_c(bel_c_values<T>::max()); }
 		};
 		template<typename T_> struct is_bel_c : std::false_type {};
 		template<typename T, typename Period> struct is_bel_c<bel_c<T, Period>> : std::true_type{};
@@ -85,27 +155,137 @@ namespace dxle {
 		}
 		template<typename To, typename T, typename Period, enable_if_t<is_bel_c<To>::value, nullptr_t>>
 		inline DXLE_CONSTEXPR To bel_cast(const bel_c<T, Period>& o)
-		{	// convert duration to another duration
+		{	// convert bel_c to another bel_c
 			typedef std::ratio_divide<Period, typename To::period> CF;
 
 			typedef typename To::value_type ToT;
 			typedef std::common_type_t<ToT, T, intmax_t> CR;
 			return detail::bel_cast_helper<To, T, Period, CF, ToT, CR, CF::num == 1, CF::den == 1>::cast(o);
-				//return (CF::num == 1 && CF::den == 1
-				//? To(static_cast<ToT>(_Dur.count()))
-				//: CF::num != 1 && CF::den == 1
-				//? To(static_cast<ToT>(
-				//	static_cast<CR>(
-				//		_Dur.count()) * static_cast<CR>(CF::num)))
-				//: CF::num == 1 && CF::den != 1
-				//? To(static_cast<ToT>(
-				//	static_cast<CR>(_Dur.count())
-				//	/ static_cast<CR>(CF::den)))
-				//: To(static_cast<ToT>(
-				//	static_cast<CR>(_Dur.count()) * static_cast<CR>(CF::num)
-				//	/ static_cast<CR>(CF::den))));
 		}
 
+		template<typename T1, typename Period1, typename T2, typename Period2>
+		constexpr common_type_t<bel_c<T1, Period1>, bel_c<T2, Period2 >>
+			operator+(const bel_c<T1, Period1>& l, const bel_c<T2, Period2>& r)
+		{
+			typedef bel_c<T1, Period1>			bel_c1;
+			typedef bel_c<T2, Period2>			bel_c2;
+			typedef common_type_t<bel_c1, bel_c2> result_t;
+			return result_t(result_t(l).count() + result_t(r).count());
+		}
+
+		template<typename T1, typename Period1, typename T2, typename Period2>
+		constexpr common_type_t<bel_c<T1, Period1>, bel_c<T2, Period2>>
+			operator-(const bel_c<T1, Period1>& l, const bel_c<T2, Period2>& r)
+		{
+			typedef bel_c<T1, Period1>			bel_c1;
+			typedef bel_c<T2, Period2>			bel_c2;
+			typedef common_type_t<bel_c1, bel_c2> result_t;
+			return result_t(result_t(l).count() - result_t(r).count());
+		}
+
+		namespace detail {
+			template<typename T2, typename Result>
+			struct common_rep_type_impl : enable_if<std::is_convertible<T2, Result>::value, Result> {};
+			template<typename T1, typename T2>
+			struct common_rep_type : common_rep_type_impl<T2, common_type_t<T1, T2>> {};
+			template<typename T1, typename T2>
+			using common_rep_type_t = typename common_rep_type<T1, T2>::type;
+		}
+
+		template<typename T1, typename _Period, typename T2>
+		constexpr bel_c<detail::common_rep_type_t<T1, T2>, _Period>
+			operator*(const bel_c<T1, _Period>& b, const T2& r)
+		{
+			typedef bel_c<common_type_t<T1, T2>, _Period> result_t;
+			return result_t(result_t(b).count() * r);
+		}
+
+		template<typename T1, typename T2, typename _Period>
+		constexpr bel_c<detail::common_rep_type_t<T2, T1>, _Period>
+			operator*(const T1& r, const bel_c<T2, _Period>& b)
+		{
+			return b * r;
+		}
+
+		template<typename T1, typename _Period, typename T2>
+		constexpr bel_c<detail::common_rep_type_t<T1, enable_if_t<!is_bel_c<T2>::value, T2>>, _Period>
+			operator/(const bel_c<T1, _Period>& b, const T2& r)
+		{
+			typedef bel_c<common_type_t<T1, T2>, _Period> result_t;
+			return result_t(result_t(b).count() / r);
+		}
+
+		template<typename T1, typename Period1, typename T2, typename Period2>
+		constexpr common_type_t<T1, T2>
+			operator/(const bel_c<T1, Period1>& l, const bel_c<T2, Period2>& r)
+		{
+			typedef bel_c<T1, Period1>			bel_c1;
+			typedef bel_c<T2, Period2>			bel_c2;
+			typedef common_type_t<bel_c1, bel_c2> result_t;
+			return result_t(l).count() / result_t(r).count();
+		}
+
+		// DR 934.
+		template<typename T1, typename _Period, typename T2>
+		constexpr bel_c<detail::common_rep_type_t<T1, enable_if_t<!is_bel_c<T2>::value, T2>>, _Period>
+			operator%(const bel_c<T1, _Period>& b, const T2& r)
+		{
+			typedef bel_c<common_type_t<T1, T2>, _Period> result_t;
+			return result_t(result_t(b).count() % r);
+		}
+
+		template<typename T1, typename Period1, typename T2, typename Period2>
+		constexpr common_type_t<bel_c<T1, Period1>, bel_c<T2, Period2>>
+			operator%(const bel_c<T1, Period1>& l, const bel_c<T2, Period2>& r)
+		{
+			typedef bel_c<T1, Period1>			bel_c1;
+			typedef bel_c<T2, Period2>			bel_c2;
+			typedef common_type_t<bel_c1, bel_c2> result_t;
+			return result_t(result_t(l).count() % result_t(r).count());
+		}
+
+		// comparisons
+		template<typename T1, typename Period1, typename T2, typename Period2>
+		constexpr bool operator==(const bel_c<T1, Period1>& l, const bel_c<T2, Period2>& r)
+		{
+			typedef bel_c<T1, Period1>			bel_c1;
+			typedef bel_c<T2, Period2>			bel_c2;
+			typedef common_type_t<bel_c1, bel_c2>	__ct;
+			return __ct(l).count() == __ct(r).count();
+		}
+
+		template<typename T1, typename Period1, typename T2, typename Period2>
+		constexpr bool operator<(const bel_c<T1, Period1>& l, const bel_c<T2, Period2>& r)
+		{
+			typedef bel_c<T1, Period1>			bel_c1;
+			typedef bel_c<T2, Period2>			bel_c2;
+			typedef common_type_t<bel_c1, bel_c2>	__ct;
+			return __ct(l).count() < __ct(r).count();
+		}
+
+		template<typename T1, typename Period1, typename T2, typename Period2>
+		constexpr bool operator!=(const bel_c<T1, Period1>& l, const bel_c<T2, Period2>& r)
+		{
+			return !(l == r);
+		}
+
+		template<typename T1, typename Period1, typename T2, typename Period2>
+		constexpr bool operator<=(const bel_c<T1, Period1>& l, const bel_c<T2, Period2>& r)
+		{
+			return !(r < l);
+		}
+
+		template<typename T1, typename Period1, typename T2, typename Period2>
+		constexpr bool operator>(const bel_c<T1, Period1>& l, const bel_c<T2, Period2>& r)
+		{
+			return r < l;
+		}
+
+		template<typename T1, typename Period1, typename T2, typename Period2>
+		constexpr bool operator>=(const bel_c<T1, Period1>& l, const bel_c<T2, Period2>& r)
+		{
+			return !(l < r);
+		}
 
 		typedef bel_c<int, myrio> myrio_bel;
 		typedef bel_c<int, std::deci> deci_bel;
diff --git a/samples/sound_play/sound_play/main.cpp b/samples/sound_play/sound_play/main.cpp
index 0e46080..4b8045e 100644
--- a/samples/sound_play/sound_play/main.cpp
+++ b/samples/sound_play/sound_play/main.cpp
@@ -1,4 +1,4 @@
-//#include <dxlibex/Sound.h>
+#include <dxlibex/Sound.h>
 #include <dxlibex/basic_types/bel.hpp>
 #include <Windows.h>
 int WINAPI WinMain(HINSTANCE /*hInstance*/, HINSTANCE /*hPrevInstance*/, LPSTR /*lpCmdLine*/, int /*nCmdShow*/) {
@@ -8,6 +8,8 @@ int WINAPI WinMain(HINSTANCE /*hInstance*/, HINSTANCE /*hPrevInstance*/, LPSTR /
 	constexpr auto rate = 300_dB;
 	constexpr auto rate2 = 4000_myrioB;
 	constexpr auto rate3 = dxle::bel_cast<dxle::bel>(rate);
+	constexpr auto rate2_2 = rate2;
 #endif
 	constexpr dxle::deci_bel rate4(100);
+	constexpr dxle::myrio_bel rate5{ 20 };
 }