path: root/include/dwu/operators

// <dwu/operators> -*- C++ -*-
// 
// Copyright (c) 2019 Wolfgang 'datenwolf' Draxinger
// 
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
// 
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
#pragma once
#ifndef DWU__OPERATORS__
#define DWU__OPERATORS__ 1

/* === Implementation Notes ===
 
   == On the use of explicitly implemented min instead of std::min ==

Within the operator functions that work on two containers, the output
length is truncated to the shorter of the two containers by an explicitly
written out min-comparison, like this:

	auto const lsz = l.size(); auto const rsz = r.size();
	Cl<T,A> v( (lsz < rsz) ? lsz : rsz );

This is used instead of std::min defined <algorithm> for two reasons:

 1. It avoids inclusion of a header. Although <algorithm> is rather
    lightweight, the extra compile time is measureable.

 2. std::min expects both inputs to be strictly of the same type. This
    however makes it impossible to do mixed container operation with
    containers that use a different size type, which however is something
    we want to support.

**/

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) { \
			auto const lsz = l.size(); auto const rsz = r.size(); \
			C<T,A> v( (lsz < rsz) ? lsz : rsz ); \
			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; \
		}
namespace arithmetic {
DWU_OPERATORS(+)
DWU_OPERATORS(-)
DWU_OPERATORS(*)
DWU_OPERATORS(/)
DWU_OPERATORS(%)
}
namespace bitwise {
DWU_OPERATORS(^)
DWU_OPERATORS(&)
DWU_OPERATORS(|)
}
namespace shift {
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 Al, \
			typename Tr > \
		C<Tl,Al> operator O (C<Tl,Al> const &l, Tr const &r) { \
			C<Tl,Al> 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 Tr, typename Ar > \
		C<Tr,Ar> operator O (Tl const &l, C<Tr,Ar> const &r) { \
			C<Tr,Ar> 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 Al, \
			typename Tr, typename Ar > \
		C<Tl,Al> operator O (C<Tl,Al> const &l, C<Tr,Ar> const &r) { \
			auto const lsz = l.size(); auto const rsz = r.size(); \
			C<Tl,Al> v( (lsz < rsz) ? lsz : rsz ); \
			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 Al, \
			typename Tr > \
		C<Tl,Al>& operator O##= (C<Tl,Al> &l, Tr const &r){ \
			for(auto &x:l){ x O##= r; } \
			return l; \
		}
namespace arithmetic {
DWU_OPERATORS_XT(+)
DWU_OPERATORS_XT(-)
DWU_OPERATORS_XT(*)
DWU_OPERATORS_XT(/)
DWU_OPERATORS_XT(%)
}
namespace bitwise {
DWU_OPERATORS_XT(^)
DWU_OPERATORS_XT(&)
DWU_OPERATORS_XT(|)
}
namespace shift {
DWU_OPERATORS_XT(>>)
DWU_OPERATORS_XT(<<)
}
#undef DWU_OPERATORS_XT
	}

	namespace operators_xc {
		// mixed container, same type
#define DWU_OPERATORS_XC(O) \
		template< \
			template<typename,typename> class Cl, \
			template<typename,typename> class Cr, \
			typename T, typename A > \
		Cl<T,A> operator O (Cl<T,A> const &l, Cr<T,A> const &r) { \
			auto const lsz = l.size(); auto const rsz = r.size(); \
			Cl<T,A> v( (lsz < rsz) ? lsz : rsz ); \
			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 T, typename A > \
		Cl<T,A>& operator O##= (Cl<T,A> &l, Cr<T,A> const &r){ \
			auto li = l.begin(); auto ri = r.begin(); \
			while( li != l.end() && ri != r.end() ){ \
				*li++ O##= *ri++; \
			} \
			return l; \
		}
namespace arithmetic {
DWU_OPERATORS_XC(+)
DWU_OPERATORS_XC(-)
DWU_OPERATORS_XC(*)
DWU_OPERATORS_XC(/)
DWU_OPERATORS_XC(%)
}
namespace bitwise {
DWU_OPERATORS_XC(^)
DWU_OPERATORS_XC(&)
DWU_OPERATORS_XC(|)
}
namespace shift {
DWU_OPERATORS_XC(>>)
DWU_OPERATORS_XC(<<)
}
#undef DWU_OPERATORS_XC
	}

	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) { \
			auto const lsz = l.size(); auto const rsz = r.size(); \
			Cl<Tl,Al> v( (lsz < rsz) ? lsz : rsz ); \
			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; \
		}
namespace arithmetic {
DWU_OPERATORS_XCXT(+)
DWU_OPERATORS_XCXT(-)
DWU_OPERATORS_XCXT(*)
DWU_OPERATORS_XCXT(/)
DWU_OPERATORS_XCXT(%)
}
namespace bitwise {
DWU_OPERATORS_XCXT(^)
DWU_OPERATORS_XCXT(&)
DWU_OPERATORS_XCXT(|)
}
namespace shift {
DWU_OPERATORS_XCXT(>>)
DWU_OPERATORS_XCXT(<<)
}
#undef DWU_OPERATORS_XCXT
	}

}

#endif/*DWU__OPERATORS__*/