simplification of std container wrappers

alib2std/src/extensions/bitset.hpp

@@ -27,23 +27,15 @@ public:
 	bitset ( ) noexcept : std::bitset < N > ( ) {
 	}
-	bitset ( const bitset & other ) noexcept : std::bitset < N > ( other ) {
-	}
-	bitset ( bitset && other ) noexcept : std::bitset < N > ( std::move ( other ) ) {
-	}
+	bitset ( const bitset & other ) = default;
+	bitset ( bitset && other ) = default;
 	using std::bitset < N >::bitset;
-	bitset & operator = ( bitset && other ) noexcept {
-		static_cast < std::bitset < N > & > ( * this ) = std::move ( other );
-		return * this;
-	}
-	bitset & operator = ( const bitset & other ) noexcept {
-		static_cast < std::bitset < N > & > ( * this ) = other;
-		return * this;
-	}
+	bitset & operator = ( bitset && other ) = default;
+	bitset & operator = ( const bitset & other ) = default;
 	using std::bitset < N >::operator =;
 #endif

alib2std/src/extensions/deque.hpp

@@ -27,23 +27,15 @@ public:
 	deque ( ) noexcept : std::deque < T, Alloc > ( ) {
 	}
-	deque ( const deque & other ) noexcept : std::deque < T, Alloc > ( other ) {
-	}
-	deque ( deque && other ) noexcept : std::deque < T, Alloc > ( std::move ( other ) ) {
-	}
+	deque ( const deque & other ) = default;
+	deque ( deque && other ) = default;
 	using std::deque < T, Alloc >::deque;
-	deque & operator = ( deque && other ) noexcept {
-		static_cast < std::deque < T, Alloc > & > ( * this ) = std::move ( other );
-		return * this;
-	}
-	deque & operator = ( const deque & other ) noexcept {
-		static_cast < std::deque < T, Alloc > & > ( * this ) = other;
-		return * this;
-	}
+	deque & operator = ( deque && other ) = default;
+	deque & operator = ( const deque & other ) = default;
 	using std::deque < T, Alloc >::operator =;
 #endif

alib2std/src/extensions/list.hpp

@@ -27,23 +27,15 @@ public:
 	list ( ) noexcept : std::list < T, Alloc > ( ) {
 	}
-	list ( const list & other ) noexcept : std::list < T, Alloc > ( other ) {
-	}
-	list ( list && other ) noexcept : std::list < T, Alloc > ( std::move ( other ) ) {
-	}
+	list ( const list & other ) = default;
+	list ( list && other ) = default;
 	using std::list < T, Alloc >::list;
-	list & operator = ( list && other ) noexcept {
-		static_cast < std::list < T, Alloc > & > ( * this ) = std::move ( other );
-		return * this;
-	}
-	list & operator = ( const list & other ) noexcept {
-		static_cast < std::list < T, Alloc > & > ( * this ) = other;
-		return * this;
-	}
+	list & operator = ( list && other ) = default;
+	list & operator = ( const list & other ) = default;
 	using std::list < T, Alloc >::operator =;
 #endif

alib2std/src/extensions/map.hpp

@@ -29,23 +29,15 @@ public:
 	map ( ) noexcept : std::map < T, R, Cmp, Alloc > ( ) {
 	}
-	map ( const map & other ) noexcept : std::map < T, R, Cmp, Alloc > ( other ) {
-	}
-	map ( map && other ) noexcept : std::map < T, R, Cmp, Alloc > ( std::move ( other ) ) {
-	}
+	map ( const map & other ) = default;
+	map ( map && other ) = default;
 	using std::map < T, R, Cmp, Alloc >::map;
-	map & operator = ( map && other ) noexcept {
-		static_cast < std::map < T, R, Cmp, Alloc > & > ( * this ) = std::move ( other );
-		return * this;
-	}
-	map & operator = ( const map & other ) noexcept {
-		static_cast < std::map < T, R, Cmp, Alloc > & > ( * this ) = other;
-		return * this;
-	}
+	map & operator = ( map && other ) = default;
+	map & operator = ( const map & other ) = default;
 	using std::map < T, R, Cmp, Alloc >::operator =;
 #endif

alib2std/src/extensions/pair.hpp

@@ -24,23 +24,15 @@ public:
 	using std::pair < T, R >::pair;
 	using std::pair < T, R >::operator =;
 #else
-	pair ( const pair & other ) noexcept : std::pair < T, R > ( other ) {
-	}
-	pair ( pair && other ) noexcept : std::pair < T, R > ( std::move ( other ) ) {
-	}
+	pair ( const pair & other ) = default;
+	pair ( pair && other ) = default;
 	using std::pair < T, R >::pair;
-	pair & operator = ( pair && other ) noexcept {
-		static_cast < std::pair < T, R > & > ( * this ) = std::move ( other );
-		return * this;
-	}
-	pair & operator = ( const pair & other ) noexcept {
-		static_cast < std::pair < T, R > & > ( * this ) = other;
-		return * this;
-	}
+	pair & operator = ( pair && other ) = default;
+	pair & operator = ( const pair & other ) = default;
 	using std::pair < T, R >::operator =;
 #endif

alib2std/src/extensions/set.hpp

@@ -27,23 +27,15 @@ public:
 	set ( ) noexcept : std::set < T, Cmp, Alloc > ( ) {
 	}
-	set ( const set & other ) noexcept : std::set < T, Cmp, Alloc > ( other ) {
-	}
-	set ( set && other ) noexcept : std::set < T, Cmp, Alloc > ( std::move ( other ) ) {
-	}
+	set ( const set & other ) = default;
+	set ( set && other ) = default;
 	using std::set < T, Cmp, Alloc >::set;
-	set & operator = ( set && other ) noexcept {
-		static_cast < std::set < T, Cmp, Alloc > & > ( * this ) = std::move ( other );
-		return * this;
-	}
-	set & operator = ( const set & other ) noexcept {
-		static_cast < std::set < T, Cmp, Alloc > & > ( * this ) = other;
-		return * this;
-	}
+	set & operator = ( set && other ) = default;
+	set & operator = ( const set & other ) = default;
 	using std::set < T, Cmp, Alloc >::operator =;
 #endif

alib2std/src/extensions/string.hpp

@@ -24,23 +24,15 @@ public:
 	string ( ) noexcept : std::string ( ) {
 	}
-	string ( const string & other ) noexcept : std::string ( other ) {
-	}
-	string ( string && other ) noexcept : std::string ( std::move ( other ) ) {
-	}
+	string ( const string & other ) = default;
+	string ( string && other ) = default;
 	using std::string::string;
-	string & operator = ( string && other ) noexcept {
-		static_cast < std::string & > ( * this ) = std::move ( other );
-		return * this;
-	}
-	string & operator = ( const string & other ) noexcept {
-		static_cast < std::string & > ( * this ) = other;
-		return * this;
-	}
+	string & operator = ( string && other ) = default;
+	string & operator = ( const string & other ) = default;
 	using std::string::operator =;
 #endif

alib2std/src/extensions/tuple.hpp

@@ -27,23 +27,15 @@ public:
 	tuple ( ) noexcept : std::tuple < Ts ... > ( ) {
 	}
-	tuple ( const tuple & other ) noexcept : std::tuple < Ts ... > ( other ) {
-	}
-	tuple ( tuple && other ) noexcept : std::tuple < Ts ... > ( std::move ( other ) ) {
-	}
+	tuple ( const tuple & other ) = default;
+	tuple ( tuple && other ) = default;
 	using std::tuple < Ts ... >::tuple;
-	tuple & operator = ( tuple && other ) noexcept {
-		static_cast < std::tuple < Ts ... > & > ( * this ) = std::move ( other );
-		return * this;
-	}
-	tuple & operator = ( const tuple & other ) noexcept {
-		static_cast < std::tuple < Ts ... > & > ( * this ) = other;
-		return * this;
-	}
+	tuple & operator = ( tuple && other ) = default;
+	tuple & operator = ( const tuple & other ) = default;
 	using std::tuple < Ts ... >::operator =;
 #endif

alib2std/src/extensions/unordered_map.hpp

@@ -27,23 +27,15 @@ public:
 	unordered_map ( ) noexcept : std::unordered_map < T, R, Hash, KeyEqual, Alloc > ( ) {
 	}
-	unordered_map ( const unordered_map & other ) noexcept : std::unordered_map < T, R, Hash, KeyEqual, Alloc > ( other ) {
-	}
-	unordered_map ( unordered_map && other ) noexcept : std::unordered_map < T, R, Hash, KeyEqual, Alloc > ( std::move ( other ) ) {
-	}
+	unordered_map ( const unordered_map & other ) = default;
+	unordered_map ( unordered_map && other ) = default;
 	using std::unordered_map < T, R, Hash, KeyEqual, Alloc >::unordered_map;
-	unordered_map & operator = ( unordered_map && other ) noexcept {
-		static_cast < std::unordered_map < T, R, Hash, KeyEqual, Alloc > & > ( * this ) = std::move ( other );
-		return * this;
-	}
-	unordered_map & operator = ( const unordered_map & other ) noexcept {
-		static_cast < std::unordered_map < T, R, Hash, KeyEqual, Alloc > & > ( * this ) = other;
-		return * this;
-	}
+	unordered_map & operator = ( unordered_map && other ) = default;
+	unordered_map & operator = ( const unordered_map & other ) = default;
 	using std::unordered_map < T, R, Hash, KeyEqual, Alloc >::operator =;
 #endif

alib2std/src/extensions/vector.hpp

@@ -27,23 +27,15 @@ public:
 	vector ( ) noexcept : std::vector < T, Alloc > ( ) {
 	}
-	vector ( const vector & other ) noexcept : std::vector < T, Alloc > ( other ) {
-	}
-	vector ( vector && other ) noexcept : std::vector < T, Alloc > ( std::move ( other ) ) {
-	}
+	vector ( const vector & other ) = default;
+	vector ( vector && other ) = default;
 	using std::vector < T, Alloc >::vector;
-	vector & operator = ( vector && other ) noexcept {
-		static_cast < std::vector < T, Alloc > & > ( * this ) = std::move ( other );
-		return * this;
-	}
-	vector & operator = ( const vector & other ) noexcept {
-		static_cast < std::vector < T, Alloc > & > ( * this ) = other;
-		return * this;
-	}
+	vector & operator = ( vector && other ) = default;
+	vector & operator = ( const vector & other ) = default;
 	using std::vector < T, Alloc >::operator =;
 #endif