1 /* Copyright 2017-2018 Fizyr B.V. - https://fizyr.com 2 * 3 * Redistribution and use in source and binary forms, with or without modification, 4 * are permitted provided that the following conditions are met: 5 * 6 * 1. Redistributions of source code must retain the above copyright notice, 7 * this list of conditions and the following disclaimer. 8 * 9 * 2. Redistributions in binary form must reproduce the above copyright notice, 10 * this list of conditions and the following disclaimer in the documentation 11 * and/or other materials provided with the distribution. 12 * 13 * 3. Neither the name of the copyright holder nor the names of its contributors 14 * may be used to endorse or promote products derived from this software without 15 * specific prior written permission. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 19 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 20 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR 21 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 22 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 23 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 24 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 26 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 */ 28 29 #include "traits/containers.hpp" 30 31 #include <vector> 32 #include <string> 33 #include <map> 34 #include <list> 35 #include <iterator> 36 37 namespace estd { 38 39 static_assert(is_iterable <int> == false); 40 static_assert(has_size <int> == false); 41 static_assert(has_reserve <int> == false); 42 static_assert(has_erase <int> == false); 43 static_assert(is_container <int> == false); 44 45 static_assert(is_iterable <std::vector<int>> == true); 46 static_assert(has_size <std::vector<int>> == true); 47 static_assert(has_reserve <std::vector<int>> == true); 48 static_assert(has_erase <std::vector<int>> == true); 49 static_assert(is_container <std::vector<int>> == true); 50 static_assert(is_contiguous_container <std::vector<int>> == true); 51 static_assert(std::is_same_v< iterator_type<std::vector<int>>, std::vector<int>::iterator>); 52 static_assert(std::is_same_v<const_iterator_type<std::vector<int>>, std::vector<int>::const_iterator>); 53 54 static_assert(is_iterable <std::list<int>> == true); 55 static_assert(has_size <std::list<int>> == true); 56 static_assert(has_reserve <std::list<int>> == false); 57 static_assert(has_erase <std::list<int>> == true); 58 static_assert(is_container <std::list<int>> == true); 59 static_assert(is_contiguous_container <std::list<int>> == false); 60 static_assert(std::is_same_v< iterator_type<std::list<int>>, std::list<int>::iterator>); 61 static_assert(std::is_same_v<const_iterator_type<std::list<int>>, std::list<int>::const_iterator>); 62 63 static_assert(is_iterable <std::string> == true); 64 static_assert(has_size <std::string> == true); 65 static_assert(has_reserve <std::string> == true); 66 static_assert(has_erase <std::string> == true); 67 static_assert(is_container <std::string> == true); 68 static_assert(is_contiguous_container <std::string> == true); 69 static_assert(std::is_same_v< iterator_type<std::string>, std::string::iterator>); 70 static_assert(std::is_same_v<const_iterator_type<std::string>, std::string::const_iterator>); 71 72 static_assert(is_iterable <std::map<int, int>> == true); 73 static_assert(has_size <std::map<int, int>> == true); 74 static_assert(has_reserve <std::map<int, int>> == false); 75 static_assert(has_erase <std::map<int, int>> == true); 76 static_assert(is_container <std::map<int, int>> == true); 77 static_assert(is_contiguous_container <std::map<int, int>> == false); 78 static_assert(std::is_same_v< iterator_type<std::map<int, int>>, std::map<int, int>::iterator>); 79 static_assert(std::is_same_v<const_iterator_type<std::map<int, int>>, std::map<int, int>::const_iterator>); 80 81 } 82