From d31ad46b724953e6895dc087aa38c92e939b6c78 Mon Sep 17 00:00:00 2001
From: Wolfgang Draxinger <dw@optores.de>
Date: Thu, 18 Jul 2019 13:55:27 +0200
Subject: split off mixed type/container operators into dedicated namespaces

---
 example/operators.cc  |  11 +--
 include/dwu/operators | 181 ++++++++++++++++++++++++++++++++++++--------------
 2 files changed, 137 insertions(+), 55 deletions(-)

diff --git a/example/operators.cc b/example/operators.cc
index d225303..14fa00b 100644
--- a/example/operators.cc
+++ b/example/operators.cc
@@ -36,11 +36,14 @@ int main(int argc, char *argv[])
 	auto vd = vb * vc;
 	dump("vd = vb * vc: ", vd);
 
-	std::list<float> la = {100, 101, 101, 103, 104, 105};
-	dump("la: ", la);
+	{
+		using namespace dwu::operators_xcxt;
+		std::list<float> la = {100, 101, 101, 103, 104, 105};
+		dump("la: ", la);
 
-	auto rr = la - vd;
-	dump("rr = la - vd: ", rr);
+		auto rr = la - vd;
+		dump("rr = la - vd: ", rr);
+	}
 
 	return 0;
 }
diff --git a/include/dwu/operators b/include/dwu/operators
index 7100301..b4b5210 100644
--- a/include/dwu/operators
+++ b/include/dwu/operators
@@ -25,56 +25,135 @@
 
 #include <algorithm>
 
-namespace dwu { namespace operators {
-#define DWU_OPERATOR(O) \
-template<template<typename,typename> class C, typename Tl, typename A, typename Tr> \
-C<Tl,A> operator O (C<Tl,A> const &l, Tr const &r) { \
-	C<Tl,A> v(l.size()); \
-	auto vi = v.begin(); auto li = l.begin(); \
-	while( vi != v.end() ){ \
-		*vi++ = *li++ O r; \
-	} \
-	return v; \
-} \
-template<template<typename,typename> class C, typename Tl, typename A, typename Tr> \
-C<Tr,A> operator O (Tl const &l, C<Tr,A> const &r) { \
-	C<Tr,A> v(r.size()); \
-	auto vi = v.begin(); auto ri = r.begin(); \
-	while( vi != v.end() ){ \
-		*vi++ = l O *ri++; \
-	} \
-	return v; \
-} \
-template<template<typename,typename> class Cl, template<typename,typename> class Cr, typename Tl, typename Al, typename Tr, typename Ar> \
-Cl<Tl,Al> operator O (Cl<Tl,Al> const &l, Cr<Tr,Ar> const &r) { \
-	Cl<Tl,Al> v( std::min(l.size(), r.size()) ); \
-	auto vi = v.begin(); auto li = l.begin(); auto ri = r.begin(); \
-	while( vi != v.end() ){ \
-		*vi++ = *li++ O *ri++; \
-	} \
-	return v; \
-} \
-template<template<typename,typename> class C, typename Tl, typename A, typename Tr> \
-C<Tl,A>& operator O##= (C<Tl,A> &l, Tr const &r){ \
-	for(auto &x:l){ x O##= r; } \
-	return l; \
-} \
-template<template<typename,typename> class Cl, template<typename,typename> class Cr, typename Tl, typename Al, typename Tr, typename Ar> \
-Cl<Tl,Al>& operator O##= (Cl<Tl,Al> &l, Cr<Tr,Ar> const &r){ \
-	auto li = l.begin(); auto ri = r.begin(); \
-	while( li != l.end() && ri != r.end() ){ \
-		*li++ O##= *ri++; \
-	} \
-	return l; \
+namespace dwu {
+	namespace operators {
+		// same container, same type
+#define DWU_OPERATORS(O) \
+		template<template<typename,typename> class C, typename T, typename A> \
+		C<T,A> operator O (C<T,A> const &l, T const &r) { \
+			C<T,A> v(l.size()); \
+			auto vi = v.begin(); auto li = l.begin(); \
+			while( vi != v.end() ){ \
+				*vi++ = *li++ O r; \
+			} \
+			return v; \
+		} \
+		template<template<typename,typename> class C, typename T, typename A> \
+		C<T,A> operator O (T const &l, C<T,A> const &r) { \
+			C<T,A> v(r.size()); \
+			auto vi = v.begin(); auto ri = r.begin(); \
+			while( vi != v.end() ){ \
+				*vi++ = l O *ri++; \
+			} \
+			return v; \
+		} \
+		template<template<typename,typename> class C, typename T, typename A> \
+		C<T,A> operator O (C<T,A> const &l, C<T,A> const &r) { \
+			C<T,A> v( std::min(l.size(), r.size()) ); \
+			auto vi = v.begin(); auto li = l.begin(); auto ri = r.begin(); \
+			while( vi != v.end() ){ \
+				*vi++ = *li++ O *ri++; \
+			} \
+			return v; \
+		} \
+		template<template<typename,typename> class C, typename T, typename A> \
+		C<T,A>& operator O##= (C<T,A> &l, T const &r){ \
+			for(auto &x:l){ x O##= r; } \
+			return l; \
+		} \
+		template<template<typename,typename> class C, typename T, typename A> \
+		C<T,A>& operator O##= (C<T,A> &l, C<T,A> const &r){ \
+			auto li = l.begin(); auto ri = r.begin(); \
+			while( li != l.end() && ri != r.end() ){ \
+				*li++ O##= *ri++; \
+			} \
+			return l; \
+		}
+DWU_OPERATORS(+)
+DWU_OPERATORS(-)
+DWU_OPERATORS(*)
+DWU_OPERATORS(/)
+DWU_OPERATORS(%)
+DWU_OPERATORS(^)
+DWU_OPERATORS(&)
+DWU_OPERATORS(|)
+#undef DWU_OPERATORS
+	}
+
+	namespace operators_xt {
+		// same container, mixed type
+#define DWU_OPERATORS_XT(O) \
+		template<template<typename,typename> class C, typename Tl, typename A, typename Tr> \
+		C<Tl,A> operator O (C<Tl,A> const &l, Tr const &r) { \
+			C<Tl,A> v(l.size()); \
+			auto vi = v.begin(); auto li = l.begin(); \
+			while( vi != v.end() ){ \
+				*vi++ = *li++ O r; \
+			} \
+			return v; \
+		} \
+		template<template<typename,typename> class C, typename Tl, typename A, typename Tr> \
+		C<Tr,A> operator O (Tl const &l, C<Tr,A> const &r) { \
+			C<Tr,A> v(r.size()); \
+			auto vi = v.begin(); auto ri = r.begin(); \
+			while( vi != v.end() ){ \
+				*vi++ = l O *ri++; \
+			} \
+			return v; \
+		} \
+		template<template<typename,typename> class C, typename Tl, typename A, typename Tr> \
+		C<Tl,A>& operator O##= (C<Tl,A> &l, Tr const &r){ \
+			for(auto &x:l){ x O##= r; } \
+			return l; \
+		}
+DWU_OPERATORS_XT(+)
+DWU_OPERATORS_XT(-)
+DWU_OPERATORS_XT(*)
+DWU_OPERATORS_XT(/)
+DWU_OPERATORS_XT(%)
+DWU_OPERATORS_XT(^)
+DWU_OPERATORS_XT(&)
+DWU_OPERATORS_XT(|)
+#undef DWU_OPERATORS_XT
+	}
+
+	namespace operators_xcxt {
+		// mixed container, mixed type
+#define DWU_OPERATORS_XCXT(O) \
+		template< \
+			template<typename,typename> class Cl, \
+			template<typename,typename> class Cr, \
+			typename Tl, typename Al, \
+			typename Tr, typename Ar > \
+		Cl<Tl,Al> operator O (Cl<Tl,Al> const &l, Cr<Tr,Ar> const &r) { \
+			Cl<Tl,Al> v( std::min(l.size(), r.size()) ); \
+			auto vi = v.begin(); auto li = l.begin(); auto ri = r.begin(); \
+			while( vi != v.end() ){ \
+				*vi++ = *li++ O *ri++; \
+			} \
+			return v; \
+		} \
+		template< \
+			template<typename,typename> class Cl, \
+			template<typename,typename> class Cr, \
+			typename Tl, typename Al, \
+			typename Tr, typename Ar > \
+		Cl<Tl,Al>& operator O##= (Cl<Tl,Al> &l, Cr<Tr,Ar> const &r){ \
+			auto li = l.begin(); auto ri = r.begin(); \
+			while( li != l.end() && ri != r.end() ){ \
+				*li++ O##= *ri++; \
+			} \
+			return l; \
+		}
+DWU_OPERATORS_XCXT(+)
+DWU_OPERATORS_XCXT(-)
+DWU_OPERATORS_XCXT(*)
+DWU_OPERATORS_XCXT(/)
+DWU_OPERATORS_XCXT(%)
+DWU_OPERATORS_XCXT(^)
+DWU_OPERATORS_XCXT(&)
+DWU_OPERATORS_XCXT(|)
+#undef DWU_OPERATORS_XCXT
+	}
 }
-DWU_OPERATOR(+)
-DWU_OPERATOR(-)
-DWU_OPERATOR(*)
-DWU_OPERATOR(/)
-DWU_OPERATOR(%)
-DWU_OPERATOR(^)
-DWU_OPERATOR(&)
-DWU_OPERATOR(|)
-} }
-#undef DWU_OPERATOR
 #endif/*DWU__OPERATORS__*/
-- 
cgit v1.2.3