├── .gitattributes
├── tests
    ├── nullopt.cpp
    ├── test_util.hpp
    ├── emplace.cpp
    ├── in_place.cpp
    ├── observers.cpp
    ├── test_workarounds.h
    ├── specialized_alg.cpp
    ├── constexpr_op.cpp
    ├── constructors.cpp
    ├── assignment.hpp
    ├── hash.cpp
    ├── noexcept_trait.cpp
    ├── relops.cpp
    ├── sfm_traits.cpp
    ├── archetypes.ipp
    ├── swap.cpp
    ├── test_macros.h
    └── archetypes.h
├── CMakeLists.txt
├── LICENSE
├── README.md
└── include
    └── swl
        └── optional.hpp


/.gitattributes:
--------------------------------------------------------------------------------
1 | # Auto detect text files and perform LF normalization
2 | * text=auto
3 | 


--------------------------------------------------------------------------------
/tests/nullopt.cpp:
--------------------------------------------------------------------------------
 1 | #include "test_util.hpp"
 2 | 
 3 | int main() {
 4 |   swl::optional<int> o1 = swl::nullopt;
 5 |   swl::optional<int> o2{swl::nullopt};
 6 |   swl::optional<int> o3(swl::nullopt);
 7 |   swl::optional<int> o4 = {swl::nullopt};
 8 | 
 9 |   assert(!o1);
10 |   assert(!o2);
11 |   assert(!o3);
12 |   assert(!o4);
13 | }
14 | 


--------------------------------------------------------------------------------
/tests/test_util.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <swl/optional.hpp>
 3 | #include <tuple>
 4 | #include <vector>
 5 | #include <cassert>
 6 | 
 7 | struct takes_init_and_variadic {
 8 |   std::vector<int> v;
 9 |   std::tuple<int, int> t;
10 |   template <class... Args>
11 |   takes_init_and_variadic(std::initializer_list<int> l, Args &&... args)
12 |       : v(l), t(std::forward<Args>(args)...) {}
13 | };


--------------------------------------------------------------------------------
/tests/emplace.cpp:
--------------------------------------------------------------------------------
 1 | #include "test_util.hpp"
 2 | #include <utility>
 3 | #include <tuple>
 4 | #include <cassert>
 5 | 
 6 | int main(){
 7 |     swl::optional<std::pair<std::pair<int,int>, std::pair<double, double>>> i;
 8 |     i.emplace(std::piecewise_construct, std::make_tuple(0,2), std::make_tuple(3,4));
 9 |     assert(i->first.first == 0);
10 |     assert(i->first.second == 2);
11 |     assert(i->second.first == 3);
12 |     assert(i->second.second == 4);    
13 | }
14 | 


--------------------------------------------------------------------------------
/tests/in_place.cpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include "test_util.hpp"
 4 | #include <tuple>
 5 | #include <vector>
 6 | #include <cassert>
 7 | 
 8 | int main() {
 9 |   swl::optional<int> o1{swl::in_place};
10 |   swl::optional<int> o2(swl::in_place);
11 |   assert(o1);
12 |   assert(o1 == 0);
13 |   assert(o2);
14 |   assert(o2 == 0);
15 | 
16 |   swl::optional<int> o3(swl::in_place, 42);
17 |   assert(o3 == 42);
18 | 
19 |   swl::optional<std::tuple<int, int>> o4(swl::in_place, 0, 1);
20 |   assert(o4);
21 |   assert(std::get<0>(*o4) == 0);
22 |   assert(std::get<1>(*o4) == 1);
23 | 
24 |   swl::optional<std::vector<int>> o5(swl::in_place, {0, 1});
25 |   assert(o5);
26 |   assert((*o5)[0] == 0);
27 |   assert((*o5)[1] == 1);
28 | 
29 |   swl::optional<takes_init_and_variadic> o6(swl::in_place, {0, 1}, 2, 3);
30 |   assert(o6->v[0] == 0);
31 |   assert(o6->v[1] == 1);
32 |   assert(std::get<0>(o6->t) == 2);
33 |   assert(std::get<1>(o6->t) == 3);
34 | }
35 | 


--------------------------------------------------------------------------------
/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required(VERSION 3.20)
 2 | 
 3 | project(swl.optional 
 4 | 	VERSION 1.0.0 
 5 | 	LANGUAGES CXX
 6 | 	HOMEPAGE_URL https://github.com/groundswellaudio/swl-optional)
 7 | 
 8 | add_library(swl-optional INTERFACE)
 9 | 
10 | target_include_directories(swl-optional INTERFACE
11 |   $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
12 |   $<INSTALL_INTERFACE:./include>)
13 | 
14 | target_compile_features(swl-optional INTERFACE cxx_std_20) 
15 | 
16 | 
17 | 
18 | if(CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME)
19 | 	
20 | 	include(CTest)
21 | 
22 | 	file(GLOB test-sources CONFIGURE_DEPENDS tests/*.cpp)
23 | 	
24 | 	foreach (source IN LISTS test-sources)
25 | 		get_filename_component(name "${source}" NAME_WE)
26 | 		set(test "${PROJECT_NAME}-test-${name}")
27 | 		add_executable(${test} "${source}")
28 | 		target_link_libraries(${test} swl-optional)
29 | 		add_test(NAME ${PROJECT_NAME}::test::${name} COMMAND ${test})
30 | 	endforeach()
31 | 	
32 | endif()
33 | 
34 | 


--------------------------------------------------------------------------------
/tests/observers.cpp:
--------------------------------------------------------------------------------
 1 | #include "test_util.hpp"
 2 | 
 3 | struct move_detector {
 4 |   move_detector() = default;
 5 |   move_detector(move_detector &&rhs) { rhs.been_moved = true; }
 6 |   bool been_moved = false;
 7 | };
 8 | 
 9 | int main()  {
10 |   swl::optional<int> o1 = 42;
11 |   swl::optional<int> o2;
12 |   const swl::optional<int> o3 = 42;
13 | 
14 |   assert(*o1 == 42);
15 |   assert(*o1 == o1.value());
16 |   assert(o2.value_or(42) == 42);
17 |   assert(o3.value() == 42);
18 |   auto success = std::is_same<decltype(o1.value()), int &>::value;
19 |   assert(success);
20 |   success = std::is_same<decltype(o3.value()), const int &>::value;
21 |   assert(success);
22 |   success = std::is_same<decltype(std::move(o1).value()), int &&>::value;
23 |   assert(success);
24 | 
25 |   success = std::is_same<decltype(std::move(o3).value()), const int &&>::value;
26 |   assert(success);
27 | 
28 |   swl::optional<move_detector> o4{swl::in_place};
29 |   move_detector o5 = std::move(o4).value();
30 |   assert(o4->been_moved);
31 |   assert(!o5.been_moved);
32 | }
33 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2021 groundswellaudio
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/tests/test_workarounds.h:
--------------------------------------------------------------------------------
 1 | // -*- C++ -*-
 2 | //===----------------------------------------------------------------------===//
 3 | //
 4 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 5 | // See https://llvm.org/LICENSE.txt for license information.
 6 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 7 | //
 8 | //===----------------------------------------------------------------------===//
 9 | 
10 | #ifndef SUPPORT_TEST_WORKAROUNDS_H
11 | #define SUPPORT_TEST_WORKAROUNDS_H
12 | 
13 | #include "test_macros.h"
14 | 
15 | #if defined(TEST_COMPILER_EDG)
16 | # define TEST_WORKAROUND_EDG_EXPLICIT_CONSTEXPR // VSO-424280
17 | #endif
18 | 
19 | #if defined(TEST_COMPILER_C1XX)
20 | # if _MSC_VER < 1927
21 | #  define TEST_WORKAROUND_C1XX_BROKEN_IS_TRIVIALLY_COPYABLE // VSO-117743
22 | # endif
23 | # ifndef _MSC_EXTENSIONS
24 | #  define TEST_WORKAROUND_C1XX_BROKEN_ZA_CTOR_CHECK // VSO-119998
25 | # endif
26 | #endif
27 | 
28 | #if defined(TEST_COMPILER_GCC)
29 | # if __GNUC__ < 9
30 | #  define TEST_WORKAROUND_CONSTEXPR_IMPLIES_NOEXCEPT // GCC-87603
31 | # endif
32 | #endif
33 | 
34 | #endif // SUPPORT_TEST_WORKAROUNDS_H
35 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # swl::optional
 2 | A standard conforming C++20 implementation of `std::optional`. 
 3 | 
 4 | C++20 came with new features that makes the implementation of `std::optional` 
 5 | (and other types based on unions) a lot simpler to write, faster to compile, and more debugger-friendly 
 6 | (ever crawled through all the `std::optional` base classes in your IDE debugger?). \
 7 | So if you're using `optional`a lot in C++20, switching to this implementation is free cookies. 
 8 | 
 9 | ## Testing
10 | The tests were adapted from [TartanLlama's optional](https://github.com/TartanLlama/optional) 
11 | with some bits from the LLVM repo. Kudos to them. \
12 | To run the tests : \
13 | `mkdir ./test_out` \
14 | `cd test_out` \
15 | `cmake ../` \
16 | `ctest --build-and-test ../ ./ --build-generator "Unix Makefiles"` (replace "Unix Makefiles" as needed) \
17 | `make test` 
18 | 
19 | ## Tested compilers
20 | - GCC 11+
21 | - GCC 10+ (the early 10.X versions have a bug in `std::construct_at`, which prevent to use it in a constexpr context, hence the tests might not compile)
22 | - Clang will not fully work as its implementation of C++20 is still incomplete (Clang 12+ will work for trivially destructible type)
23 | 


--------------------------------------------------------------------------------
/tests/specialized_alg.cpp:
--------------------------------------------------------------------------------
 1 | #include "test_util.hpp"
 2 | 
 3 | #include <tuple>
 4 | #include <vector>
 5 | 
 6 | int main() {
 7 |   auto o1 = swl::make_optional(42);
 8 |   auto o2 = swl::optional<int>(42);
 9 | 
10 |   constexpr bool is_same = std::is_same<decltype(o1), swl::optional<int>>::value;
11 |   assert(is_same);
12 |   assert(o1 == o2);
13 | 
14 |   auto o3 = swl::make_optional<std::tuple<int, int, int, int>>(0, 1, 2, 3);
15 |   assert(std::get<0>(*o3) == 0);
16 |   assert(std::get<1>(*o3) == 1);
17 |   assert(std::get<2>(*o3) == 2);
18 |   assert(std::get<3>(*o3) == 3);
19 | 
20 |   auto o4 = swl::make_optional<std::vector<int>>({0, 1, 2, 3});
21 |   assert(o4.value()[0] == 0);
22 |   assert(o4.value()[1] == 1);
23 |   assert(o4.value()[2] == 2);
24 |   assert(o4.value()[3] == 3);
25 | 
26 |   auto o5 = swl::make_optional<takes_init_and_variadic>({0, 1}, 2, 3);
27 |   assert(o5->v[0] == 0);
28 |   assert(o5->v[1] == 1);
29 |   assert(std::get<0>(o5->t) == 2);
30 |   assert(std::get<1>(o5->t) == 3);
31 | 	
32 |   /* 
33 |   auto i = 42;
34 |   auto o6 = swl::make_optional<int&>(i);
35 |   assert((std::is_same<decltype(o6), swl::optional<int&>>::value));
36 |   assert(o6);
37 |   assert(*o6 == 42); */ 
38 | }
39 | 


--------------------------------------------------------------------------------
/tests/constexpr_op.cpp:
--------------------------------------------------------------------------------
 1 | #include "test_util.hpp"
 2 | 
 3 | int main(){
 4 |   {
 5 |     constexpr swl::optional<int> o2{};
 6 |     constexpr swl::optional<int> o3 = {};
 7 |     constexpr swl::optional<int> o4 = swl::nullopt;
 8 |     constexpr swl::optional<int> o5 = {swl::nullopt};
 9 |     constexpr swl::optional<int> o6(swl::nullopt);
10 | 
11 |     static_assert(!o2);
12 |     static_assert(!o3);
13 |     static_assert(!o4);
14 |     static_assert(!o5);
15 |     static_assert(!o6);
16 |   }
17 | 
18 |   {
19 |     constexpr swl::optional<int> o1 = 42;
20 |     constexpr swl::optional<int> o2{42};
21 |     constexpr swl::optional<int> o3(42);
22 |     constexpr swl::optional<int> o4 = {42};
23 |     constexpr int i = 42;
24 |     constexpr swl::optional<int> o5 = std::move(i);
25 |     constexpr swl::optional<int> o6{std::move(i)};
26 |     constexpr swl::optional<int> o7(std::move(i));
27 |     constexpr swl::optional<int> o8 = {std::move(i)};
28 | 
29 |     static_assert(*o1 == 42);
30 |     static_assert(*o2 == 42);
31 |     static_assert(*o3 == 42);
32 |     static_assert(*o4 == 42);
33 |     static_assert(*o5 == 42);
34 |     static_assert(*o6 == 42);
35 |     static_assert(*o7 == 42);
36 |     static_assert(*o8 == 42);
37 |   }
38 | }
39 | 


--------------------------------------------------------------------------------
/tests/constructors.cpp:
--------------------------------------------------------------------------------
 1 | #include "test_util.hpp"
 2 | #include <vector>
 3 | 
 4 | struct foo {
 5 |   foo() = default;
 6 |   foo(foo&) = delete;
 7 |   foo(foo&&) {};
 8 | };
 9 | 
10 | int main(){
11 |   swl::optional<int> o1;
12 |   assert(!o1);
13 | 
14 |   swl::optional<int> o2 = swl::nullopt;
15 |   assert(!o2);
16 | 
17 |   swl::optional<int> o3 = 42;
18 |   assert(*o3 == 42);
19 | 
20 |   swl::optional<int> o4 = o3;
21 |   assert(*o4 == 42);
22 | 
23 |   swl::optional<int> o5 = o1;
24 |   assert(!o5);
25 | 
26 |   swl::optional<int> o6 = std::move(o3);
27 |   assert(*o6 == 42);
28 | 
29 |   swl::optional<short> o7 = 42;
30 |   assert(*o7 == 42);
31 | 
32 |   swl::optional<int> o8 = o7;
33 |   assert(*o8 == 42);
34 | 
35 |   swl::optional<int> o9 = std::move(o7);
36 |   assert(*o9 == 42);
37 | 	
38 | /* 
39 |   {
40 |     swl::optional<int &> o;
41 |     assert(!o);
42 | 
43 |     swl::optional<int &> oo = o;
44 |     assert(!oo);
45 |   }
46 |   {
47 |     auto i = 42;
48 |     swl::optional<int &> o = i;
49 |     assert(o);
50 |     assert(*o == 42);
51 | 
52 |     swl::optional<int &> oo = o;
53 |     assert(oo);
54 |     assert(*oo == 42);
55 |   }
56 |   */ 
57 | 
58 |   std::vector<foo> v;
59 |   v.emplace_back();
60 |   swl::optional<std::vector<foo>> ov = std::move(v);
61 |   assert(ov->size() == 1);
62 | }
63 | 


--------------------------------------------------------------------------------
/tests/assignment.hpp:
--------------------------------------------------------------------------------
 1 | #include "test_util.hpp"
 2 | #include <cassert>
 3 | 
 4 | inline void assignement() {
 5 |     swl::optional<int> o1 = 42;
 6 |     swl::optional<int> o2 = 12;
 7 |     swl::optional<int> o3;
 8 | 
 9 |     o1 = o1;
10 |     assert(*o1 == 42);
11 | 
12 |     o1 = o2;
13 |     assert(*o1 == 12);
14 | 
15 |     o1 = o3;
16 |     assert(!o1);
17 | 
18 |     o1 = 42;
19 |     assert(*o1 == 42);
20 | 
21 |     o1 = swl::nullopt;
22 |     assert(!o1);
23 | 
24 |     o1 = std::move(o2);
25 |     assert(*o1 == 12);
26 | 
27 |     swl::optional<short> o4 = 42;
28 | 
29 |     o1 = o4;
30 |     assert(*o1 == 42);
31 | 
32 |     o1 = std::move(o4);
33 |     assert(*o1 == 42);
34 | }
35 | 
36 | /* 
37 | TEST_CASE("Assignment reference", "[assignment.ref]") {
38 |     auto i = 42;
39 |     auto j = 12;
40 |     
41 |     swl::optional<int&> o1 = i;
42 |     swl::optional<int&> o2 = j;
43 |     swl::optional<int&> o3;
44 | 
45 |     o1 = o1;
46 |     assert(*o1 == 42);
47 |     assert(&*o1 == &i);    
48 | 
49 |     o1 = o2;
50 |     assert(*o1 == 12);
51 | 
52 |     o1 = o3;
53 |     assert(!o1);
54 | 
55 |     auto k = 42;
56 |     o1 = k;
57 |     assert(*o1 == 42);
58 |     assert(*o1 == i);
59 |     assert(*o1 == k);        
60 |     assert(&*o1 != &i);
61 |     assert(&*o1 == &k);
62 | 
63 |     k = 12;
64 |     assert(*o1 == 12);
65 | 
66 |     o1 = swl::nullopt;
67 |     assert(!o1);
68 | 
69 |     o1 = std::move(o2);
70 |     assert(*o1 == 12);
71 | } */ 
72 | 


--------------------------------------------------------------------------------
/tests/hash.cpp:
--------------------------------------------------------------------------------
 1 | #include "test_util.hpp"
 2 | 
 3 | #include <string>
 4 | #include <memory>
 5 | #include <cassert>
 6 | 
 7 | namespace hash_test_impl{
 8 | 	struct A {};
 9 | 	struct B {};
10 | }
11 | 
12 | namespace std {
13 | 	template <>
14 | 	struct hash<hash_test_impl::B> {
15 | 	  size_t operator()(hash_test_impl::B const&) { return 0; }
16 | 	};
17 | }
18 | 
19 | template <class T>
20 | inline void test_hash_enabled_for_type(){
21 | 	static_assert( requires{ std::hash<T>{}; } );
22 | }
23 | 
24 | template <class T>
25 | inline void test_hash_disabled_for_type(){
26 | 	static_assert( not requires{ std::hash<T>{}; } );
27 | }
28 | 
29 | int main()
30 | {
31 | 	using namespace hash_test_impl;
32 | 	using swl::optional;
33 | 	
34 |     const std::size_t nullopt_hash =
35 |         std::hash<optional<double>>{}(optional<double>{});
36 | 
37 | 	/* 
38 |     {
39 |         optional<B> opt;
40 |         ASSERT_NOT_NOEXCEPT(std::hash<optional<B>>()(opt));
41 |         ASSERT_NOT_NOEXCEPT(std::hash<optional<const B>>()(opt));
42 |     } */ 
43 | 
44 |     {
45 |         typedef int T;
46 |         optional<T> opt;
47 |         assert(std::hash<optional<T>>{}(opt) == nullopt_hash);
48 |         opt = 2;
49 |         assert(std::hash<optional<T>>{}(opt) == std::hash<T>{}(*opt));
50 |     }
51 |     {
52 |         typedef std::string T;
53 |         optional<T> opt;
54 |         assert(std::hash<optional<T>>{}(opt) == nullopt_hash);
55 |         opt = std::string("123");
56 |         assert(std::hash<optional<T>>{}(opt) == std::hash<T>{}(*opt));
57 |     }
58 |     {
59 |         typedef std::unique_ptr<int> T;
60 |         optional<T> opt;
61 |         assert(std::hash<optional<T>>{}(opt) == nullopt_hash);
62 |         opt = std::unique_ptr<int>(new int(3));
63 |         assert(std::hash<optional<T>>{}(opt) == std::hash<T>{}(*opt));
64 |     }
65 |     {
66 |       test_hash_enabled_for_type<optional<int> >();
67 |       test_hash_enabled_for_type<optional<int*> >();
68 |       test_hash_enabled_for_type<optional<const int> >();
69 |       test_hash_enabled_for_type<optional<int* const> >();
70 | 
71 |       test_hash_disabled_for_type<optional<A>>();
72 |       test_hash_disabled_for_type<optional<const A>>();
73 | 	
74 |       test_hash_enabled_for_type<optional<B>>();
75 |       test_hash_enabled_for_type<optional<const B>>();
76 |     }
77 | }
78 | 


--------------------------------------------------------------------------------
/tests/noexcept_trait.cpp:
--------------------------------------------------------------------------------
 1 | #include "test_util.hpp"
 2 | 
 3 | int main() {
 4 |   swl::optional<int> o1{4};
 5 |   swl::optional<int> o2{42};
 6 | 
 7 |   {
 8 |     assert(noexcept(o1 == swl::nullopt));
 9 |     assert(noexcept(swl::nullopt == o1));
10 |     assert(noexcept(o1 != swl::nullopt));
11 |     assert(noexcept(swl::nullopt != o1));
12 |     assert(noexcept(o1 < swl::nullopt));
13 |     assert(noexcept(swl::nullopt < o1));
14 |     assert(noexcept(o1 <= swl::nullopt));
15 |     assert(noexcept(swl::nullopt <= o1));
16 |     assert(noexcept(o1 > swl::nullopt));
17 |     assert(noexcept(swl::nullopt > o1));
18 |     assert(noexcept(o1 >= swl::nullopt));
19 |     assert(noexcept(swl::nullopt >= o1));
20 |   }
21 |   
22 | 
23 |   {
24 |     struct nothrow_swappable {
25 |       nothrow_swappable &swap(const nothrow_swappable &) noexcept {
26 |         return *this;
27 |       }
28 |     };
29 | 
30 |     struct throw_swappable {
31 |       throw_swappable() = default;
32 |       throw_swappable(const throw_swappable &) {}
33 |       throw_swappable(throw_swappable &&) {}
34 |       throw_swappable &swap(const throw_swappable &) { return *this; }
35 |     };
36 | 
37 |     swl::optional<nothrow_swappable> ont;
38 |     swl::optional<throw_swappable> ot;
39 | 
40 |     assert(noexcept(ont.swap(ont)));
41 |     assert(!noexcept(ot.swap(ot)));
42 |   }
43 | 
44 |   {
45 |     assert(noexcept(swl::optional<int>{}));
46 |     assert(noexcept(swl::optional<int>{swl::nullopt}));
47 | 
48 |     struct nothrow_move {
49 |       nothrow_move(nothrow_move &&) noexcept = default;
50 |     };
51 | 
52 |     struct throw_move {
53 |       throw_move(throw_move &&){};
54 |     };
55 | 
56 |     using nothrow_opt = swl::optional<nothrow_move>;
57 |     using throw_opt = swl::optional<throw_move>;
58 | 
59 |     assert(std::is_nothrow_move_constructible<nothrow_opt>::value);
60 |     assert(!std::is_nothrow_move_constructible<throw_opt>::value);
61 |   }
62 | 
63 |   {
64 |     assert(noexcept(o1 = swl::nullopt));
65 | 
66 |     struct nothrow_move_assign {
67 |       nothrow_move_assign() = default;
68 |       nothrow_move_assign(nothrow_move_assign &&) noexcept = default;
69 |       nothrow_move_assign &operator=(const nothrow_move_assign &) = default;
70 |     };
71 | 
72 |     struct throw_move_assign {
73 |       throw_move_assign() = default;
74 |       throw_move_assign(throw_move_assign &&){};
75 |       throw_move_assign &operator=(const throw_move_assign &) { return *this; }
76 |     };
77 | 
78 |     using nothrow_opt = swl::optional<nothrow_move_assign>;
79 |     using throw_opt = swl::optional<throw_move_assign>;
80 | 
81 |     assert(noexcept(std::declval<nothrow_opt>() = std::declval<nothrow_opt>()));
82 |     assert(!noexcept(std::declval<throw_opt>() = std::declval<throw_opt>()));
83 |   }
84 | 
85 |   {
86 |     assert(noexcept(static_cast<bool>(o1)));
87 |     assert(noexcept(o1.has_value()));
88 |   }
89 | 
90 |   { 
91 |   	assert(noexcept(o1.reset())); 
92 |   }
93 | }
94 | 


--------------------------------------------------------------------------------
/tests/relops.cpp:
--------------------------------------------------------------------------------
  1 | #include "test_util.hpp"
  2 | 
  3 | int main() {
  4 |   swl::optional<int> o1{4};
  5 |   swl::optional<int> o2{42};
  6 |   swl::optional<int> o3{};
  7 | 
  8 |   {
  9 |     assert(!(o1 == o2));
 10 |     assert(o1 == o1);
 11 |     assert(o1 != o2);
 12 |     assert(!(o1 != o1));
 13 |     assert(o1 < o2);
 14 |     assert(!(o1 < o1));
 15 |     assert(!(o1 > o2));
 16 |     assert(!(o1 > o1));
 17 |     assert(o1 <= o2);
 18 |     assert(o1 <= o1);
 19 |     assert(!(o1 >= o2));
 20 |     assert(o1 >= o1);
 21 |   }
 22 | 
 23 |   {
 24 |     assert(!(o1 == swl::nullopt));
 25 |     assert(!(swl::nullopt == o1));
 26 |     assert(o1 != swl::nullopt);
 27 |     assert(swl::nullopt != o1);
 28 |     assert(!(o1 < swl::nullopt));
 29 |     assert(swl::nullopt < o1);
 30 |     assert(o1 > swl::nullopt);
 31 |     assert(!(swl::nullopt > o1));
 32 |     assert(!(o1 <= swl::nullopt));
 33 |     assert(swl::nullopt <= o1);
 34 |     assert(o1 >= swl::nullopt);
 35 |     assert(!(swl::nullopt >= o1));
 36 | 
 37 |     assert(o3 == swl::nullopt);
 38 |     assert(swl::nullopt == o3);
 39 |     assert(!(o3 != swl::nullopt));
 40 |     assert(!(swl::nullopt != o3));
 41 |     assert(!(o3 < swl::nullopt));
 42 |     assert(!(swl::nullopt < o3));
 43 |     assert(!(o3 > swl::nullopt));
 44 |     assert(!(swl::nullopt > o3));
 45 |     assert(o3 <= swl::nullopt);
 46 |     assert(swl::nullopt <= o3);
 47 |     assert(o3 >= swl::nullopt);
 48 |     assert(swl::nullopt >= o3);
 49 |   }
 50 | 
 51 |   {
 52 |     assert(!(o1 == 1));
 53 |     assert(!(1 == o1));
 54 |     assert(o1 != 1);
 55 |     assert(1 != o1);
 56 |     assert(!(o1 < 1));
 57 |     assert(1 < o1);
 58 |     assert(o1 > 1);
 59 |     assert(!(1 > o1));
 60 |     assert(!(o1 <= 1));
 61 |     assert(1 <= o1);
 62 |     assert(o1 >= 1);
 63 |     assert(!(1 >= o1));
 64 | 
 65 |     assert(o1 == 4);
 66 |     assert(4 == o1);
 67 |     assert(!(o1 != 4));
 68 |     assert(!(4 != o1));
 69 |     assert(!(o1 < 4));
 70 |     assert(!(4 < o1));
 71 |     assert(!(o1 > 4));
 72 |     assert(!(4 > o1));
 73 |     assert(o1 <= 4);
 74 |     assert(4 <= o1);
 75 |     assert(o1 >= 4);
 76 |     assert(4 >= o1);
 77 |   }
 78 | 
 79 |   swl::optional<std::string> o4{"hello"};
 80 |   swl::optional<std::string> o5{"xyz"};
 81 | 
 82 |   {
 83 |     assert(!(o4 == o5));
 84 |     assert(o4 == o4);
 85 |     assert(o4 != o5);
 86 |     assert(!(o4 != o4));
 87 |     assert(o4 < o5);
 88 |     assert(!(o4 < o4));
 89 |     assert(!(o4 > o5));
 90 |     assert(!(o4 > o4));
 91 |     assert(o4 <= o5);
 92 |     assert(o4 <= o4);
 93 |     assert(!(o4 >= o5));
 94 |     assert(o4 >= o4);
 95 |   }
 96 | 
 97 |   {
 98 |     assert(!(o4 == swl::nullopt));
 99 |     assert(!(swl::nullopt == o4));
100 |     assert(o4 != swl::nullopt);
101 |     assert(swl::nullopt != o4);
102 |     assert(!(o4 < swl::nullopt));
103 |     assert(swl::nullopt < o4);
104 |     assert(o4 > swl::nullopt);
105 |     assert(!(swl::nullopt > o4));
106 |     assert(!(o4 <= swl::nullopt));
107 |     assert(swl::nullopt <= o4);
108 |     assert(o4 >= swl::nullopt);
109 |     assert(!(swl::nullopt >= o4));
110 | 
111 |     assert(o3 == swl::nullopt);
112 |     assert(swl::nullopt == o3);
113 |     assert(!(o3 != swl::nullopt));
114 |     assert(!(swl::nullopt != o3));
115 |     assert(!(o3 < swl::nullopt));
116 |     assert(!(swl::nullopt < o3));
117 |     assert(!(o3 > swl::nullopt));
118 |     assert(!(swl::nullopt > o3));
119 |     assert(o3 <= swl::nullopt);
120 |     assert(swl::nullopt <= o3);
121 |     assert(o3 >= swl::nullopt);
122 |     assert(swl::nullopt >= o3);
123 |   }
124 | 
125 |   {
126 |     assert(!(o4 == "a"));
127 |     assert(!("a" == o4));
128 |     assert(o4 != "a");
129 |     assert("a" != o4);
130 |     assert(!(o4 < "a"));
131 |     assert("a" < o4);
132 |     assert(o4 > "a");
133 |     assert(!("a" > o4));
134 |     assert(!(o4 <= "a"));
135 |     assert("a" <= o4);
136 |     assert(o4 >= "a");
137 |     assert(!("a" >= o4));
138 | 
139 |     assert(o4 == "hello");
140 |     assert("hello" == o4);
141 |     assert(!(o4 != "hello"));
142 |     assert(!("hello" != o4));
143 |     assert(!(o4 < "hello"));
144 |     assert(!("hello" < o4));
145 |     assert(!(o4 > "hello"));
146 |     assert(!("hello" > o4));
147 |     assert(o4 <= "hello");
148 |     assert("hello" <= o4);
149 |     assert(o4 >= "hello");
150 |     assert("hello" >= o4);
151 |   }
152 | }
153 | 


--------------------------------------------------------------------------------
/tests/sfm_traits.cpp:
--------------------------------------------------------------------------------
  1 | #include "test_util.hpp"
  2 | #include <type_traits>
  3 | 
  4 | int main() {
  5 |     static_assert(std::is_trivially_copy_constructible<swl::optional<int>>::value);
  6 |     static_assert(std::is_trivially_copy_assignable<swl::optional<int>>::value);
  7 |     static_assert(std::is_trivially_move_constructible<swl::optional<int>>::value);
  8 |     static_assert(std::is_trivially_move_assignable<swl::optional<int>>::value);
  9 |     static_assert(std::is_trivially_destructible<swl::optional<int>>::value);
 10 | 
 11 |     {
 12 |         struct T {
 13 |             T(const T&) = default;
 14 |             T(T&&) = default;
 15 |             T& operator=(const T&) = default;
 16 |             T& operator=(T&&) = default;
 17 |             ~T() = default;
 18 |         };
 19 |         static_assert(std::is_trivially_copy_constructible<swl::optional<T>>::value);
 20 |         static_assert(std::is_trivially_copy_assignable<swl::optional<T>>::value);
 21 |         static_assert(std::is_trivially_move_constructible<swl::optional<T>>::value);
 22 |         static_assert(std::is_trivially_move_assignable<swl::optional<T>>::value);
 23 |         static_assert(std::is_trivially_destructible<swl::optional<T>>::value);
 24 |     }
 25 | 
 26 |     {
 27 |         struct T {
 28 |             T(const T&){}
 29 |             T(T&&) {};
 30 |             T& operator=(const T&) { return *this; }
 31 |             T& operator=(T&&) { return *this; };
 32 |             ~T(){}
 33 |         };
 34 |         static_assert(!std::is_trivially_copy_constructible<swl::optional<T>>::value);
 35 |         static_assert(!std::is_trivially_copy_assignable<swl::optional<T>>::value);
 36 |         static_assert(!std::is_trivially_move_constructible<swl::optional<T>>::value);
 37 |         static_assert(!std::is_trivially_move_assignable<swl::optional<T>>::value);
 38 |         static_assert(!std::is_trivially_destructible<swl::optional<T>>::value);
 39 |     }
 40 | 	
 41 | 	
 42 | 	// ====================
 43 | 	
 44 |     static_assert(std::is_copy_constructible<swl::optional<int>>::value);
 45 |     static_assert(std::is_copy_assignable<swl::optional<int>>::value);
 46 |     static_assert(std::is_move_constructible<swl::optional<int>>::value);
 47 |     static_assert(std::is_move_assignable<swl::optional<int>>::value);
 48 |     static_assert(std::is_destructible<swl::optional<int>>::value);
 49 | 
 50 |     {
 51 |         struct T {
 52 |             T(const T&) = default;
 53 |             T(T&&) = default;
 54 |             T& operator=(const T&) = default;
 55 |             T& operator=(T&&) = default;
 56 |             ~T() = default;
 57 |         };
 58 |         static_assert(std::is_copy_constructible<swl::optional<T>>::value);
 59 |         static_assert(std::is_copy_assignable<swl::optional<T>>::value);
 60 |         static_assert(std::is_move_constructible<swl::optional<T>>::value);
 61 |         static_assert(std::is_move_assignable<swl::optional<T>>::value);
 62 |         static_assert(std::is_destructible<swl::optional<T>>::value);
 63 |     }
 64 | 
 65 |     {
 66 |         struct T {
 67 |             T(const T&)=delete;
 68 |             T(T&&)=delete;
 69 |             T& operator=(const T&)=delete;
 70 |             T& operator=(T&&)=delete;
 71 |         };
 72 |         static_assert(!std::is_copy_constructible<swl::optional<T>>::value);
 73 |         static_assert(!std::is_copy_assignable<swl::optional<T>>::value);
 74 |         static_assert(!std::is_move_constructible<swl::optional<T>>::value);
 75 |         static_assert(!std::is_move_assignable<swl::optional<T>>::value);
 76 |     }
 77 | 
 78 |     {
 79 |         struct T {
 80 |             T(const T&)=delete;
 81 |             T(T&&)=default;
 82 |             T& operator=(const T&)=delete;
 83 |             T& operator=(T&&)=default;
 84 |         };
 85 |         static_assert(!std::is_copy_constructible<swl::optional<T>>::value);
 86 |         static_assert(!std::is_copy_assignable<swl::optional<T>>::value);
 87 |         static_assert(std::is_move_constructible<swl::optional<T>>::value);
 88 |         static_assert(std::is_move_assignable<swl::optional<T>>::value);
 89 |     }
 90 | 
 91 |     {
 92 |         struct T {
 93 |             T(const T&)=default;
 94 |             T(T&&)=delete;
 95 |             T& operator=(const T&)=default;
 96 |             T& operator=(T&&)=delete;
 97 |         };
 98 |         static_assert(std::is_copy_constructible<swl::optional<T>>::value);
 99 |         static_assert(std::is_copy_assignable<swl::optional<T>>::value);
100 |     }
101 | }
102 | 


--------------------------------------------------------------------------------
/tests/archetypes.ipp:
--------------------------------------------------------------------------------
  1 | //===----------------------------------------------------------------------===//
  2 | //
  3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  4 | // See https://llvm.org/LICENSE.txt for license information.
  5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  6 | //
  7 | //===----------------------------------------------------------------------===//
  8 | 
  9 | #ifndef DEFINE_BASE
 10 | #define DEFINE_BASE(Name) ::ArchetypeBases::NullBase
 11 | #endif
 12 | #ifndef DEFINE_EXPLICIT
 13 | #define DEFINE_EXPLICIT
 14 | #endif
 15 | #ifndef DEFINE_NOEXCEPT
 16 | #define DEFINE_NOEXCEPT
 17 | #endif
 18 | #ifndef DEFINE_CONSTEXPR
 19 | #ifdef TEST_WORKAROUND_EDG_EXPLICIT_CONSTEXPR
 20 | #define DEFINE_CONSTEXPR
 21 | #else // TEST_WORKAROUND_EDG_EXPLICIT_CONSTEXPR
 22 | #define DEFINE_CONSTEXPR constexpr
 23 | #endif // TEST_WORKAROUND_EDG_EXPLICIT_CONSTEXPR
 24 | #endif
 25 | #ifndef DEFINE_ASSIGN_CONSTEXPR
 26 | #if TEST_STD_VER >= 14
 27 | #define DEFINE_ASSIGN_CONSTEXPR DEFINE_CONSTEXPR
 28 | #else
 29 | #define DEFINE_ASSIGN_CONSTEXPR
 30 | #endif
 31 | #endif
 32 | #ifndef DEFINE_CTOR
 33 | #define DEFINE_CTOR = default
 34 | #endif
 35 | #ifndef DEFINE_DEFAULT_CTOR
 36 | #define DEFINE_DEFAULT_CTOR DEFINE_CTOR
 37 | #endif
 38 | #ifndef DEFINE_ASSIGN
 39 | #define DEFINE_ASSIGN = default
 40 | #endif
 41 | #ifndef DEFINE_DTOR
 42 | #define DEFINE_DTOR(Name)
 43 | #endif
 44 | 
 45 | struct AllCtors : DEFINE_BASE(AllCtors) {
 46 |   using Base = DEFINE_BASE(AllCtors);
 47 |   using Base::Base;
 48 |   using Base::operator=;
 49 |   DEFINE_EXPLICIT DEFINE_CONSTEXPR AllCtors() DEFINE_NOEXCEPT DEFINE_DEFAULT_CTOR;
 50 |   DEFINE_EXPLICIT DEFINE_CONSTEXPR AllCtors(AllCtors const&) DEFINE_NOEXCEPT DEFINE_CTOR;
 51 |   DEFINE_EXPLICIT DEFINE_CONSTEXPR AllCtors(AllCtors &&) DEFINE_NOEXCEPT DEFINE_CTOR;
 52 |   DEFINE_ASSIGN_CONSTEXPR AllCtors& operator=(AllCtors const&) DEFINE_NOEXCEPT DEFINE_ASSIGN;
 53 |   DEFINE_ASSIGN_CONSTEXPR AllCtors& operator=(AllCtors &&) DEFINE_NOEXCEPT DEFINE_ASSIGN;
 54 |   DEFINE_DTOR(AllCtors)
 55 | };
 56 | 
 57 | struct NoCtors : DEFINE_BASE(NoCtors) {
 58 |   using Base = DEFINE_BASE(NoCtors);
 59 |   DEFINE_EXPLICIT NoCtors() DEFINE_NOEXCEPT = delete;
 60 |   DEFINE_EXPLICIT NoCtors(NoCtors const&) DEFINE_NOEXCEPT = delete;
 61 |   NoCtors& operator=(NoCtors const&) DEFINE_NOEXCEPT = delete;
 62 |   DEFINE_DTOR(NoCtors)
 63 | };
 64 | 
 65 | struct NoDefault : DEFINE_BASE(NoDefault) {
 66 |   using Base = DEFINE_BASE(NoDefault);
 67 |   using Base::Base;
 68 |   DEFINE_EXPLICIT DEFINE_CONSTEXPR NoDefault() DEFINE_NOEXCEPT = delete;
 69 |   DEFINE_DTOR(NoDefault)
 70 | };
 71 | 
 72 | struct DefaultOnly : DEFINE_BASE(DefaultOnly) {
 73 |   using Base = DEFINE_BASE(DefaultOnly);
 74 |   using Base::Base;
 75 |   DEFINE_EXPLICIT DEFINE_CONSTEXPR DefaultOnly() DEFINE_NOEXCEPT DEFINE_DEFAULT_CTOR;
 76 |   DefaultOnly(DefaultOnly const&) DEFINE_NOEXCEPT = delete;
 77 |   DefaultOnly& operator=(DefaultOnly const&) DEFINE_NOEXCEPT = delete;
 78 |   DEFINE_DTOR(DefaultOnly)
 79 | };
 80 | 
 81 | struct Copyable : DEFINE_BASE(Copyable) {
 82 |   using Base = DEFINE_BASE(Copyable);
 83 |   using Base::Base;
 84 |   DEFINE_EXPLICIT DEFINE_CONSTEXPR Copyable() DEFINE_NOEXCEPT DEFINE_DEFAULT_CTOR;
 85 |   DEFINE_EXPLICIT DEFINE_CONSTEXPR Copyable(Copyable const &) DEFINE_NOEXCEPT DEFINE_CTOR;
 86 |   Copyable &operator=(Copyable const &) DEFINE_NOEXCEPT DEFINE_ASSIGN;
 87 |   DEFINE_DTOR(Copyable)
 88 | };
 89 | 
 90 | struct CopyOnly : DEFINE_BASE(CopyOnly) {
 91 |   using Base = DEFINE_BASE(CopyOnly);
 92 |   using Base::Base;
 93 |   DEFINE_EXPLICIT DEFINE_CONSTEXPR CopyOnly() DEFINE_NOEXCEPT DEFINE_DEFAULT_CTOR;
 94 |   DEFINE_EXPLICIT DEFINE_CONSTEXPR CopyOnly(CopyOnly const &) DEFINE_NOEXCEPT DEFINE_CTOR;
 95 |   DEFINE_EXPLICIT DEFINE_CONSTEXPR CopyOnly(CopyOnly &&) DEFINE_NOEXCEPT = delete;
 96 |   CopyOnly &operator=(CopyOnly const &) DEFINE_NOEXCEPT DEFINE_ASSIGN;
 97 |   CopyOnly &operator=(CopyOnly &&) DEFINE_NOEXCEPT = delete;
 98 |   DEFINE_DTOR(CopyOnly)
 99 | };
100 | 
101 | struct NonCopyable : DEFINE_BASE(NonCopyable) {
102 |   using Base = DEFINE_BASE(NonCopyable);
103 |   using Base::Base;
104 |   DEFINE_EXPLICIT DEFINE_CONSTEXPR NonCopyable() DEFINE_NOEXCEPT DEFINE_DEFAULT_CTOR;
105 |   DEFINE_EXPLICIT DEFINE_CONSTEXPR NonCopyable(NonCopyable const &) DEFINE_NOEXCEPT = delete;
106 |   NonCopyable &operator=(NonCopyable const &) DEFINE_NOEXCEPT = delete;
107 |   DEFINE_DTOR(NonCopyable)
108 | };
109 | 
110 | struct MoveOnly : DEFINE_BASE(MoveOnly) {
111 |   using Base = DEFINE_BASE(MoveOnly);
112 |   using Base::Base;
113 |   DEFINE_EXPLICIT DEFINE_CONSTEXPR MoveOnly() DEFINE_NOEXCEPT DEFINE_DEFAULT_CTOR;
114 |   DEFINE_EXPLICIT DEFINE_CONSTEXPR MoveOnly(MoveOnly &&) DEFINE_NOEXCEPT DEFINE_CTOR;
115 |   MoveOnly &operator=(MoveOnly &&) DEFINE_NOEXCEPT DEFINE_ASSIGN;
116 |   DEFINE_DTOR(MoveOnly)
117 | };
118 | 
119 | struct CopyAssignable : DEFINE_BASE(CopyAssignable) {
120 |   using Base = DEFINE_BASE(CopyAssignable);
121 |   using Base::Base;
122 |   DEFINE_EXPLICIT DEFINE_CONSTEXPR CopyAssignable() DEFINE_NOEXCEPT = delete;
123 |   CopyAssignable& operator=(CopyAssignable const&) DEFINE_NOEXCEPT DEFINE_ASSIGN;
124 |   DEFINE_DTOR(CopyAssignable)
125 | };
126 | 
127 | struct CopyAssignOnly : DEFINE_BASE(CopyAssignOnly) {
128 |   using Base = DEFINE_BASE(CopyAssignOnly);
129 |   using Base::Base;
130 |   DEFINE_EXPLICIT DEFINE_CONSTEXPR CopyAssignOnly() DEFINE_NOEXCEPT = delete;
131 |   CopyAssignOnly& operator=(CopyAssignOnly const&) DEFINE_NOEXCEPT DEFINE_ASSIGN;
132 |   CopyAssignOnly& operator=(CopyAssignOnly &&) DEFINE_NOEXCEPT = delete;
133 |   DEFINE_DTOR(CopyAssignOnly)
134 | };
135 | 
136 | struct MoveAssignOnly : DEFINE_BASE(MoveAssignOnly) {
137 |   using Base = DEFINE_BASE(MoveAssignOnly);
138 |   using Base::Base;
139 |   DEFINE_EXPLICIT DEFINE_CONSTEXPR MoveAssignOnly() DEFINE_NOEXCEPT = delete;
140 |   MoveAssignOnly& operator=(MoveAssignOnly const&) DEFINE_NOEXCEPT = delete;
141 |   MoveAssignOnly& operator=(MoveAssignOnly &&) DEFINE_NOEXCEPT DEFINE_ASSIGN;
142 |   DEFINE_DTOR(MoveAssignOnly)
143 | };
144 | 
145 | struct ConvertingType : DEFINE_BASE(ConvertingType) {
146 |   using Base = DEFINE_BASE(ConvertingType);
147 |   using Base::Base;
148 |   DEFINE_EXPLICIT DEFINE_CONSTEXPR ConvertingType() DEFINE_NOEXCEPT DEFINE_DEFAULT_CTOR;
149 |   DEFINE_EXPLICIT DEFINE_CONSTEXPR ConvertingType(ConvertingType const&) DEFINE_NOEXCEPT DEFINE_CTOR;
150 |   DEFINE_EXPLICIT DEFINE_CONSTEXPR ConvertingType(ConvertingType &&) DEFINE_NOEXCEPT DEFINE_CTOR;
151 |   ConvertingType& operator=(ConvertingType const&) DEFINE_NOEXCEPT DEFINE_ASSIGN;
152 |   ConvertingType& operator=(ConvertingType &&) DEFINE_NOEXCEPT DEFINE_ASSIGN;
153 |   template <class ...Args>
154 |   DEFINE_EXPLICIT DEFINE_CONSTEXPR ConvertingType(Args&&...) DEFINE_NOEXCEPT {}
155 |   template <class Arg>
156 |   ConvertingType& operator=(Arg&&) DEFINE_NOEXCEPT { return *this; }
157 |   DEFINE_DTOR(ConvertingType)
158 | };
159 | 
160 | template <template <class...> class List>
161 | using ApplyTypes = List<
162 |     AllCtors,
163 |     NoCtors,
164 |     NoDefault,
165 |     DefaultOnly,
166 |     Copyable,
167 |     CopyOnly,
168 |     NonCopyable,
169 |     MoveOnly,
170 |     CopyAssignable,
171 |     CopyAssignOnly,
172 |     MoveAssignOnly,
173 |     ConvertingType
174 |   >;
175 | 
176 | #undef DEFINE_BASE
177 | #undef DEFINE_EXPLICIT
178 | #undef DEFINE_NOEXCEPT
179 | #undef DEFINE_CONSTEXPR
180 | #undef DEFINE_ASSIGN_CONSTEXPR
181 | #undef DEFINE_CTOR
182 | #undef DEFINE_DEFAULT_CTOR
183 | #undef DEFINE_ASSIGN
184 | #undef DEFINE_DTOR
185 | 


--------------------------------------------------------------------------------
/tests/swap.cpp:
--------------------------------------------------------------------------------
  1 | //===----------------------------------------------------------------------===//
  2 | //
  3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  4 | // See https://llvm.org/LICENSE.txt for license information.
  5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  6 | //
  7 | //===----------------------------------------------------------------------===//
  8 | 
  9 | #include "test_util.hpp"
 10 | #include "test_macros.h"
 11 | #include "archetypes.h"
 12 | 
 13 | namespace swap_impl {
 14 | 	
 15 | 	using swl::optional;
 16 | 	
 17 | class X
 18 | {
 19 |     int i_;
 20 | public:
 21 |     static unsigned dtor_called;
 22 |     X(int i) : i_(i) {}
 23 |     X(X&& x) = default;
 24 |     X& operator=(X&&) = default;
 25 |     ~X() {++dtor_called;}
 26 | 
 27 |     friend bool operator==(const X& x, const X& y) {return x.i_ == y.i_;}
 28 | };
 29 | 
 30 | unsigned X::dtor_called = 0;
 31 | 
 32 | class Y
 33 | {
 34 |     int i_;
 35 | public:
 36 |     static unsigned dtor_called;
 37 |     Y(int i) : i_(i) {}
 38 |     Y(Y&&) = default;
 39 |     ~Y() {++dtor_called;}
 40 | 
 41 |     friend constexpr bool operator==(const Y& x, const Y& y) {return x.i_ == y.i_;}
 42 |     friend void swap(Y& x, Y& y) {std::swap(x.i_, y.i_);}
 43 | };
 44 | 
 45 | unsigned Y::dtor_called = 0;
 46 | 
 47 | class Z
 48 | {
 49 |     int i_;
 50 | public:
 51 |     Z(int i) : i_(i) {}
 52 |     Z(Z&&) { TEST_THROW(7);}
 53 | 
 54 |     friend constexpr bool operator==(const Z& x, const Z& y) {return x.i_ == y.i_;}
 55 |     friend void swap(Z&, Z&) { TEST_THROW(6);}
 56 | };
 57 | 
 58 | 
 59 | struct NonSwappable {
 60 |     NonSwappable(NonSwappable const&) = delete;
 61 | };
 62 | void swap(NonSwappable&, NonSwappable&) = delete;
 63 | 
 64 | void test_swap_sfinae() {
 65 |     using swl::optional;
 66 |     {
 67 |         using T = TestTypes::TestType;
 68 |         static_assert(std::is_swappable_v<optional<T>>, "");
 69 |     }
 70 |     {
 71 |         using T = TestTypes::MoveOnly;
 72 |         static_assert(std::is_swappable_v<optional<T>>, "");
 73 |     }
 74 |     {
 75 |         using T = TestTypes::Copyable;
 76 |         static_assert(std::is_swappable_v<optional<T>>, "");
 77 |     }
 78 |     {
 79 |         using T = TestTypes::NoCtors;
 80 |         static_assert(!std::is_swappable_v<optional<T>>, "");
 81 |     }
 82 |     {
 83 |         using T = NonSwappable;
 84 |         static_assert(!std::is_swappable_v<optional<T>>, "");
 85 |     }
 86 |     {
 87 |         // Even though CopyOnly has deleted move operations, those operations
 88 |         // cause optional<CopyOnly> to have implicitly deleted move operations
 89 |         // that decay into copies.
 90 |         using T = TestTypes::CopyOnly;
 91 |         using Opt = optional<T>;
 92 |         T::reset();
 93 |         Opt L(101), R(42);
 94 |         T::reset_constructors();
 95 |         std::swap(L, R);
 96 |         assert(L->value == 42);
 97 |         assert(R->value == 101);
 98 |         assert(T::copy_constructed == 1);
 99 |         assert(T::constructed == T::copy_constructed);
100 |         assert(T::assigned == 2);
101 |         assert(T::assigned == T::copy_assigned);
102 |     }
103 | }
104 | 
105 | } // SWAP_IMPL 
106 | 
107 | int main() 
108 | {
109 | 	using namespace swap_impl;
110 | 	using swl::optional;
111 | 	
112 |     test_swap_sfinae();
113 |     {
114 |         optional<int> opt1;
115 |         optional<int> opt2;
116 |         static_assert(noexcept(swap(opt1, opt2)) == true, "");
117 |         assert(static_cast<bool>(opt1) == false);
118 |         assert(static_cast<bool>(opt2) == false);
119 |         swap(opt1, opt2);
120 |         assert(static_cast<bool>(opt1) == false);
121 |         assert(static_cast<bool>(opt2) == false);
122 |     }
123 |     {
124 |         optional<int> opt1(1);
125 |         optional<int> opt2;
126 |         static_assert(noexcept(swap(opt1, opt2)) == true, "");
127 |         assert(static_cast<bool>(opt1) == true);
128 |         assert(*opt1 == 1);
129 |         assert(static_cast<bool>(opt2) == false);
130 |         swap(opt1, opt2);
131 |         assert(static_cast<bool>(opt1) == false);
132 |         assert(static_cast<bool>(opt2) == true);
133 |         assert(*opt2 == 1);
134 |     }
135 |     {
136 |         optional<int> opt1;
137 |         optional<int> opt2(2);
138 |         static_assert(noexcept(swap(opt1, opt2)) == true, "");
139 |         assert(static_cast<bool>(opt1) == false);
140 |         assert(static_cast<bool>(opt2) == true);
141 |         assert(*opt2 == 2);
142 |         swap(opt1, opt2);
143 |         assert(static_cast<bool>(opt1) == true);
144 |         assert(*opt1 == 2);
145 |         assert(static_cast<bool>(opt2) == false);
146 |     }
147 |     {
148 |         optional<int> opt1(1);
149 |         optional<int> opt2(2);
150 |         static_assert(noexcept(swap(opt1, opt2)) == true, "");
151 |         assert(static_cast<bool>(opt1) == true);
152 |         assert(*opt1 == 1);
153 |         assert(static_cast<bool>(opt2) == true);
154 |         assert(*opt2 == 2);
155 |         swap(opt1, opt2);
156 |         assert(static_cast<bool>(opt1) == true);
157 |         assert(*opt1 == 2);
158 |         assert(static_cast<bool>(opt2) == true);
159 |         assert(*opt2 == 1);
160 |     }
161 |     {
162 |         optional<X> opt1;
163 |         optional<X> opt2;
164 |         static_assert(noexcept(swap(opt1, opt2)) == true, "");
165 |         assert(static_cast<bool>(opt1) == false);
166 |         assert(static_cast<bool>(opt2) == false);
167 |         swap(opt1, opt2);
168 |         assert(static_cast<bool>(opt1) == false);
169 |         assert(static_cast<bool>(opt2) == false);
170 |         assert(X::dtor_called == 0);
171 |     }
172 |     {
173 |         optional<X> opt1(1);
174 |         optional<X> opt2;
175 |         static_assert(noexcept(swap(opt1, opt2)) == true, "");
176 |         assert(static_cast<bool>(opt1) == true);
177 |         assert(*opt1 == 1);
178 |         assert(static_cast<bool>(opt2) == false);
179 |         X::dtor_called = 0;
180 |         swap(opt1, opt2);
181 |         assert(X::dtor_called == 1);
182 |         assert(static_cast<bool>(opt1) == false);
183 |         assert(static_cast<bool>(opt2) == true);
184 |         assert(*opt2 == 1);
185 |     }
186 |     {
187 |         optional<X> opt1;
188 |         optional<X> opt2(2);
189 |         static_assert(noexcept(swap(opt1, opt2)) == true, "");
190 |         assert(static_cast<bool>(opt1) == false);
191 |         assert(static_cast<bool>(opt2) == true);
192 |         assert(*opt2 == 2);
193 |         X::dtor_called = 0;
194 |         swap(opt1, opt2);
195 |         assert(X::dtor_called == 1);
196 |         assert(static_cast<bool>(opt1) == true);
197 |         assert(*opt1 == 2);
198 |         assert(static_cast<bool>(opt2) == false);
199 |     }
200 |     {
201 |         optional<X> opt1(1);
202 |         optional<X> opt2(2);
203 |         static_assert(noexcept(swap(opt1, opt2)) == true, "");
204 |         assert(static_cast<bool>(opt1) == true);
205 |         assert(*opt1 == 1);
206 |         assert(static_cast<bool>(opt2) == true);
207 |         assert(*opt2 == 2);
208 |         X::dtor_called = 0;
209 |         swap(opt1, opt2);
210 |         assert(X::dtor_called == 1);  // from inside std::swap
211 |         assert(static_cast<bool>(opt1) == true);
212 |         assert(*opt1 == 2);
213 |         assert(static_cast<bool>(opt2) == true);
214 |         assert(*opt2 == 1);
215 |     }
216 |     {
217 |         optional<Y> opt1;
218 |         optional<Y> opt2;
219 |         static_assert(noexcept(swap(opt1, opt2)) == false, "");
220 |         assert(static_cast<bool>(opt1) == false);
221 |         assert(static_cast<bool>(opt2) == false);
222 |         swap(opt1, opt2);
223 |         assert(static_cast<bool>(opt1) == false);
224 |         assert(static_cast<bool>(opt2) == false);
225 |         assert(Y::dtor_called == 0);
226 |     }
227 |     {
228 |         optional<Y> opt1(1);
229 |         optional<Y> opt2;
230 |         static_assert(noexcept(swap(opt1, opt2)) == false, "");
231 |         assert(static_cast<bool>(opt1) == true);
232 |         assert(*opt1 == 1);
233 |         assert(static_cast<bool>(opt2) == false);
234 |         Y::dtor_called = 0;
235 |         swap(opt1, opt2);
236 |         assert(Y::dtor_called == 1);
237 |         assert(static_cast<bool>(opt1) == false);
238 |         assert(static_cast<bool>(opt2) == true);
239 |         assert(*opt2 == 1);
240 |     }
241 |     {
242 |         optional<Y> opt1;
243 |         optional<Y> opt2(2);
244 |         static_assert(noexcept(swap(opt1, opt2)) == false, "");
245 |         assert(static_cast<bool>(opt1) == false);
246 |         assert(static_cast<bool>(opt2) == true);
247 |         assert(*opt2 == 2);
248 |         Y::dtor_called = 0;
249 |         swap(opt1, opt2);
250 |         assert(Y::dtor_called == 1);
251 |         assert(static_cast<bool>(opt1) == true);
252 |         assert(*opt1 == 2);
253 |         assert(static_cast<bool>(opt2) == false);
254 |     }
255 |     {
256 |         optional<Y> opt1(1);
257 |         optional<Y> opt2(2);
258 |         static_assert(noexcept(swap(opt1, opt2)) == false, "");
259 |         assert(static_cast<bool>(opt1) == true);
260 |         assert(*opt1 == 1);
261 |         assert(static_cast<bool>(opt2) == true);
262 |         assert(*opt2 == 2);
263 |         Y::dtor_called = 0;
264 |         swap(opt1, opt2);
265 |         assert(Y::dtor_called == 0);
266 |         assert(static_cast<bool>(opt1) == true);
267 |         assert(*opt1 == 2);
268 |         assert(static_cast<bool>(opt2) == true);
269 |         assert(*opt2 == 1);
270 |     }
271 |     {
272 |         optional<Z> opt1;
273 |         optional<Z> opt2;
274 |         static_assert(noexcept(swap(opt1, opt2)) == false, "");
275 |         assert(static_cast<bool>(opt1) == false);
276 |         assert(static_cast<bool>(opt2) == false);
277 |         swap(opt1, opt2);
278 |         assert(static_cast<bool>(opt1) == false);
279 |         assert(static_cast<bool>(opt2) == false);
280 |     }
281 |     
282 |     {
283 |         optional<Z> opt1;
284 |         opt1.emplace(1);
285 |         optional<Z> opt2;
286 |         static_assert(noexcept(swap(opt1, opt2)) == false, "");
287 |         assert(static_cast<bool>(opt1) == true);
288 |         assert(*opt1 == 1);
289 |         assert(static_cast<bool>(opt2) == false);
290 |         try
291 |         {
292 |             swap(opt1, opt2);
293 |             assert(false);
294 |         }
295 |         catch (int i)
296 |         {
297 |             assert(i == 7);
298 |         }
299 |         assert(static_cast<bool>(opt1) == true);
300 |         assert(*opt1 == 1);
301 |         assert(static_cast<bool>(opt2) == false);
302 |     }
303 |     {
304 |         optional<Z> opt1;
305 |         optional<Z> opt2;
306 |         opt2.emplace(2);
307 |         static_assert(noexcept(swap(opt1, opt2)) == false, "");
308 |         assert(static_cast<bool>(opt1) == false);
309 |         assert(static_cast<bool>(opt2) == true);
310 |         assert(*opt2 == 2);
311 |         try
312 |         {
313 |             swap(opt1, opt2);
314 |             assert(false);
315 |         }
316 |         catch (int i)
317 |         {
318 |             assert(i == 7);
319 |         }
320 |         assert(static_cast<bool>(opt1) == false);
321 |         assert(static_cast<bool>(opt2) == true);
322 |         assert(*opt2 == 2);
323 |     }
324 |     {
325 |         optional<Z> opt1;
326 |         opt1.emplace(1);
327 |         optional<Z> opt2;
328 |         opt2.emplace(2);
329 |         static_assert(noexcept(swap(opt1, opt2)) == false, "");
330 |         assert(static_cast<bool>(opt1) == true);
331 |         assert(*opt1 == 1);
332 |         assert(static_cast<bool>(opt2) == true);
333 |         assert(*opt2 == 2);
334 |         try
335 |         {
336 |             swap(opt1, opt2);
337 |             assert(false);
338 |         }
339 |         catch (int i)
340 |         {
341 |             assert(i == 6);
342 |         }
343 |         assert(static_cast<bool>(opt1) == true);
344 |         assert(*opt1 == 1);
345 |         assert(static_cast<bool>(opt2) == true);
346 |         assert(*opt2 == 2);
347 |     }
348 | }
349 | 
350 | 


--------------------------------------------------------------------------------
/tests/test_macros.h:
--------------------------------------------------------------------------------
  1 | // -*- C++ -*-
  2 | //===---------------------------- test_macros.h ---------------------------===//
  3 | //
  4 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  5 | // See https://llvm.org/LICENSE.txt for license information.
  6 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  7 | //
  8 | //===----------------------------------------------------------------------===//
  9 | 
 10 | #ifndef SUPPORT_TEST_MACROS_HPP
 11 | #define SUPPORT_TEST_MACROS_HPP
 12 | 
 13 | // Attempt to get STL specific macros like _LIBCPP_VERSION using the most
 14 | // minimal header possible. If we're testing libc++, we should use `<__config>`.
 15 | // If <__config> isn't available, fall back to <ciso646>.
 16 | #ifdef __has_include
 17 | # if __has_include("<__config>")
 18 | #   include <__config>
 19 | #   define TEST_IMP_INCLUDED_HEADER
 20 | # endif
 21 | #endif
 22 | #ifndef TEST_IMP_INCLUDED_HEADER
 23 | #include <ciso646>
 24 | #endif
 25 | 
 26 | #if defined(__GNUC__)
 27 | #pragma GCC diagnostic push
 28 | #pragma GCC diagnostic ignored "-Wvariadic-macros"
 29 | #endif
 30 | 
 31 | #define TEST_STRINGIZE_IMPL(x) #x
 32 | #define TEST_STRINGIZE(x) TEST_STRINGIZE_IMPL(x)
 33 | 
 34 | #define TEST_CONCAT1(X, Y) X##Y
 35 | #define TEST_CONCAT(X, Y) TEST_CONCAT1(X, Y)
 36 | 
 37 | #ifdef __has_feature
 38 | #define TEST_HAS_FEATURE(X) __has_feature(X)
 39 | #else
 40 | #define TEST_HAS_FEATURE(X) 0
 41 | #endif
 42 | 
 43 | #ifndef __has_include
 44 | #define __has_include(...) 0
 45 | #endif
 46 | 
 47 | #ifdef __has_extension
 48 | #define TEST_HAS_EXTENSION(X) __has_extension(X)
 49 | #else
 50 | #define TEST_HAS_EXTENSION(X) 0
 51 | #endif
 52 | 
 53 | #ifdef __has_warning
 54 | #define TEST_HAS_WARNING(X) __has_warning(X)
 55 | #else
 56 | #define TEST_HAS_WARNING(X) 0
 57 | #endif
 58 | 
 59 | #ifdef __has_builtin
 60 | #define TEST_HAS_BUILTIN(X) __has_builtin(X)
 61 | #else
 62 | #define TEST_HAS_BUILTIN(X) 0
 63 | #endif
 64 | #ifdef __is_identifier
 65 | // '__is_identifier' returns '0' if '__x' is a reserved identifier provided by
 66 | // the compiler and '1' otherwise.
 67 | #define TEST_HAS_BUILTIN_IDENTIFIER(X) !__is_identifier(X)
 68 | #else
 69 | #define TEST_HAS_BUILTIN_IDENTIFIER(X) 0
 70 | #endif
 71 | 
 72 | #if defined(__EDG__)
 73 | # define TEST_COMPILER_EDG
 74 | #elif defined(__clang__)
 75 | # define TEST_COMPILER_CLANG
 76 | # if defined(__apple_build_version__)
 77 | #  define TEST_COMPILER_APPLE_CLANG
 78 | # endif
 79 | #elif defined(_MSC_VER)
 80 | # define TEST_COMPILER_C1XX
 81 | #elif defined(__GNUC__)
 82 | # define TEST_COMPILER_GCC
 83 | #endif
 84 | 
 85 | #if defined(__apple_build_version__)
 86 | #define TEST_APPLE_CLANG_VER (__clang_major__ * 100) + __clang_minor__
 87 | #elif defined(__clang_major__)
 88 | #define TEST_CLANG_VER (__clang_major__ * 100) + __clang_minor__
 89 | #elif defined(__GNUC__)
 90 | #define TEST_GCC_VER (__GNUC__ * 100 + __GNUC_MINOR__)
 91 | #define TEST_GCC_VER_NEW (TEST_GCC_VER * 10 + __GNUC_PATCHLEVEL__)
 92 | #endif
 93 | 
 94 | /* Make a nice name for the standard version */
 95 | #ifndef TEST_STD_VER
 96 | #if  __cplusplus <= 199711L
 97 | # define TEST_STD_VER 3
 98 | #elif __cplusplus <= 201103L
 99 | # define TEST_STD_VER 11
100 | #elif __cplusplus <= 201402L
101 | # define TEST_STD_VER 14
102 | #elif __cplusplus <= 201703L
103 | # define TEST_STD_VER 17
104 | #elif __cplusplus <= 202002L
105 | # define TEST_STD_VER 20
106 | #else
107 | # define TEST_STD_VER 99    // greater than current standard
108 | // This is deliberately different than _LIBCPP_STD_VER to discourage matching them up.
109 | #endif
110 | #endif
111 | 
112 | // Attempt to deduce the GLIBC version
113 | #if (defined(__has_include) && __has_include(<features.h>)) || \
114 |     defined(__linux__)
115 | #include <features.h>
116 | #if defined(__GLIBC_PREREQ)
117 | #define TEST_HAS_GLIBC
118 | #define TEST_GLIBC_PREREQ(major, minor) __GLIBC_PREREQ(major, minor)
119 | #endif
120 | #endif
121 | 
122 | #if TEST_STD_VER >= 11
123 | # define TEST_ALIGNOF(...) alignof(__VA_ARGS__)
124 | # define TEST_ALIGNAS(...) alignas(__VA_ARGS__)
125 | # define TEST_CONSTEXPR constexpr
126 | # define TEST_NOEXCEPT noexcept
127 | # define TEST_NOEXCEPT_FALSE noexcept(false)
128 | # define TEST_NOEXCEPT_COND(...) noexcept(__VA_ARGS__)
129 | #else
130 | #   if defined(TEST_COMPILER_CLANG)
131 | #    define TEST_ALIGNOF(...) _Alignof(__VA_ARGS__)
132 | #   else
133 | #    define TEST_ALIGNOF(...) __alignof(__VA_ARGS__)
134 | #   endif
135 | # define TEST_ALIGNAS(...) __attribute__((__aligned__(__VA_ARGS__)))
136 | # define TEST_CONSTEXPR
137 | # define TEST_NOEXCEPT throw()
138 | # define TEST_NOEXCEPT_FALSE
139 | # define TEST_NOEXCEPT_COND(...)
140 | #endif
141 | 
142 | #if TEST_STD_VER >= 17
143 | # define TEST_THROW_SPEC(...)
144 | #else
145 | # define TEST_THROW_SPEC(...) throw(__VA_ARGS__)
146 | #endif
147 | 
148 | #if TEST_STD_VER >= 14
149 | # define TEST_CONSTEXPR_CXX14 constexpr
150 | #else
151 | # define TEST_CONSTEXPR_CXX14
152 | #endif
153 | 
154 | #if TEST_STD_VER >= 17
155 | # define TEST_CONSTEXPR_CXX17 constexpr
156 | #else
157 | # define TEST_CONSTEXPR_CXX17
158 | #endif
159 | 
160 | #if TEST_STD_VER >= 20
161 | # define TEST_CONSTEXPR_CXX20 constexpr
162 | #else
163 | # define TEST_CONSTEXPR_CXX20
164 | #endif
165 | 
166 | // Sniff out to see if the underlying C library has C11 features
167 | // This is cribbed from __config; but lives here as well because we can't assume libc++
168 | #if __ISO_C_VISIBLE >= 2011 || TEST_STD_VER >= 11
169 | #  if defined(__FreeBSD__)
170 | #    if __FreeBSD_version >= 1300064 || \
171 |        (__FreeBSD_version >= 1201504 && __FreeBSD_version < 1300000)
172 | #      define TEST_HAS_TIMESPEC_GET
173 | #    endif
174 | #    define TEST_HAS_ALIGNED_ALLOC
175 | #    define TEST_HAS_QUICK_EXIT
176 | #  elif defined(__BIONIC__)
177 | #    if __ANDROID_API__ >= 21
178 | #      define TEST_HAS_QUICK_EXIT
179 | #    endif
180 | #    if __ANDROID_API__ >= 28
181 | #      define TEST_HAS_ALIGNED_ALLOC
182 | #    endif
183 | #    if __ANDROID_API__ >= 29
184 | #      define TEST_HAS_TIMESPEC_GET
185 | #    endif
186 | #  elif defined(__Fuchsia__) || defined(__wasi__) || defined(__NetBSD__)
187 | #    define TEST_HAS_QUICK_EXIT
188 | #    define TEST_HAS_ALIGNED_ALLOC
189 | #    define TEST_HAS_TIMESPEC_GET
190 | #  elif defined(__linux__)
191 | // This block preserves the old behavior used by include/__config:
192 | // _LIBCPP_GLIBC_PREREQ would be defined to 0 if __GLIBC_PREREQ was not
193 | // available. The configuration here may be too vague though, as Bionic, uClibc,
194 | // newlib, etc may all support these features but need to be configured.
195 | #    if defined(TEST_GLIBC_PREREQ)
196 | #      if TEST_GLIBC_PREREQ(2, 15)
197 | #        define TEST_HAS_QUICK_EXIT
198 | #      endif
199 | #      if TEST_GLIBC_PREREQ(2, 17)
200 | #        define TEST_HAS_ALIGNED_ALLOC
201 | #        define TEST_HAS_TIMESPEC_GET
202 | #      endif
203 | #    elif defined(_LIBCPP_HAS_MUSL_LIBC)
204 | #      define TEST_HAS_QUICK_EXIT
205 | #      define TEST_HAS_ALIGNED_ALLOC
206 | #      define TEST_HAS_TIMESPEC_GET
207 | #    endif
208 | #  elif defined(_WIN32)
209 | #    if defined(_MSC_VER) && !defined(__MINGW32__)
210 | #      define TEST_HAS_QUICK_EXIT
211 | #      define TEST_HAS_ALIGNED_ALLOC
212 | #      define TEST_HAS_TIMESPEC_GET
213 | #    endif
214 | #  elif defined(__APPLE__)
215 |      // timespec_get and aligned_alloc were introduced in macOS 10.15 and
216 |      // aligned releases
217 | #    if (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 101500 || \
218 |          __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 130000 || \
219 |          __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ >= 130000 || \
220 |          __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ >= 60000)
221 | #      define TEST_HAS_ALIGNED_ALLOC
222 | #      define TEST_HAS_TIMESPEC_GET
223 | #    endif
224 | #  endif // __APPLE__
225 | #endif
226 | 
227 | /* Features that were introduced in C++14 */
228 | #if TEST_STD_VER >= 14
229 | #define TEST_HAS_EXTENDED_CONSTEXPR
230 | #define TEST_HAS_VARIABLE_TEMPLATES
231 | #endif
232 | 
233 | /* Features that were introduced in C++17 */
234 | #if TEST_STD_VER >= 17
235 | #endif
236 | 
237 | /* Features that were introduced after C++17 */
238 | #if TEST_STD_VER > 17
239 | #endif
240 | 
241 | 
242 | #define TEST_ALIGNAS_TYPE(...) TEST_ALIGNAS(TEST_ALIGNOF(__VA_ARGS__))
243 | 
244 | #if !TEST_HAS_FEATURE(cxx_rtti) && !defined(__cpp_rtti) \
245 |     && !defined(__GXX_RTTI)
246 | #define TEST_HAS_NO_RTTI
247 | #endif
248 | 
249 | #if !defined(TEST_HAS_NO_RTTI)
250 | # define RTTI_ASSERT(X) assert(X)
251 | #else
252 | # define RTTI_ASSERT(X)
253 | #endif
254 | 
255 | #if !TEST_HAS_FEATURE(cxx_exceptions) && !defined(__cpp_exceptions) \
256 |      && !defined(__EXCEPTIONS)
257 | #define TEST_HAS_NO_EXCEPTIONS
258 | #endif
259 | 
260 | #if TEST_HAS_FEATURE(address_sanitizer) || TEST_HAS_FEATURE(memory_sanitizer) || \
261 |     TEST_HAS_FEATURE(thread_sanitizer)
262 | #define TEST_HAS_SANITIZERS
263 | #endif
264 | 
265 | #if defined(_LIBCPP_NORETURN)
266 | #define TEST_NORETURN _LIBCPP_NORETURN
267 | #else
268 | #define TEST_NORETURN [[noreturn]]
269 | #endif
270 | 
271 | #if defined(_LIBCPP_HAS_NO_ALIGNED_ALLOCATION) || \
272 |   (!(TEST_STD_VER > 14 || \
273 |     (defined(__cpp_aligned_new) && __cpp_aligned_new >= 201606L)))
274 | #define TEST_HAS_NO_ALIGNED_ALLOCATION
275 | #endif
276 | 
277 | #if defined(_LIBCPP_SAFE_STATIC)
278 | #define TEST_SAFE_STATIC _LIBCPP_SAFE_STATIC
279 | #else
280 | #define TEST_SAFE_STATIC
281 | #endif
282 | 
283 | #if !defined(__cpp_impl_three_way_comparison) \
284 |     && (!defined(_MSC_VER) || defined(__clang__) || _MSC_VER < 1920 || _MSVC_LANG <= 201703L)
285 | #define TEST_HAS_NO_SPACESHIP_OPERATOR
286 | #endif
287 | 
288 | #if TEST_STD_VER < 11
289 | #define ASSERT_NOEXCEPT(...)
290 | #define ASSERT_NOT_NOEXCEPT(...)
291 | #else
292 | #define ASSERT_NOEXCEPT(...) \
293 |     static_assert(noexcept(__VA_ARGS__), "Operation must be noexcept")
294 | 
295 | #define ASSERT_NOT_NOEXCEPT(...) \
296 |     static_assert(!noexcept(__VA_ARGS__), "Operation must NOT be noexcept")
297 | #endif
298 | 
299 | /* Macros for testing libc++ specific behavior and extensions */
300 | #if defined(_LIBCPP_VERSION)
301 | #define LIBCPP_ASSERT(...) assert(__VA_ARGS__)
302 | #define LIBCPP_STATIC_ASSERT(...) static_assert(__VA_ARGS__)
303 | #define LIBCPP_ASSERT_NOEXCEPT(...) ASSERT_NOEXCEPT(__VA_ARGS__)
304 | #define LIBCPP_ASSERT_NOT_NOEXCEPT(...) ASSERT_NOT_NOEXCEPT(__VA_ARGS__)
305 | #define LIBCPP_ONLY(...) __VA_ARGS__
306 | #else
307 | #define LIBCPP_ASSERT(...) ((void)0)
308 | #define LIBCPP_STATIC_ASSERT(...) ((void)0)
309 | #define LIBCPP_ASSERT_NOEXCEPT(...) ((void)0)
310 | #define LIBCPP_ASSERT_NOT_NOEXCEPT(...) ((void)0)
311 | #define LIBCPP_ONLY(...) ((void)0)
312 | #endif
313 | 
314 | #define TEST_IGNORE_NODISCARD (void)
315 | 
316 | namespace test_macros_detail {
317 | template <class T, class U>
318 | struct is_same { enum { value = 0};} ;
319 | template <class T>
320 | struct is_same<T, T> { enum {value = 1}; };
321 | } // namespace test_macros_detail
322 | 
323 | #define ASSERT_SAME_TYPE(...) \
324 |     static_assert((test_macros_detail::is_same<__VA_ARGS__>::value), \
325 |                  "Types differ unexpectedly")
326 | 
327 | #ifndef TEST_HAS_NO_EXCEPTIONS
328 | #define TEST_THROW(...) throw __VA_ARGS__
329 | #else
330 | #if defined(__GNUC__)
331 | #define TEST_THROW(...) __builtin_abort()
332 | #else
333 | #include <stdlib.h>
334 | #define TEST_THROW(...) ::abort()
335 | #endif
336 | #endif
337 | 
338 | #if defined(__GNUC__) || defined(__clang__)
339 | template <class Tp>
340 | inline
341 | void DoNotOptimize(Tp const& value) {
342 |     asm volatile("" : : "r,m"(value) : "memory");
343 | }
344 | 
345 | template <class Tp>
346 | inline void DoNotOptimize(Tp& value) {
347 | #if defined(__clang__)
348 |   asm volatile("" : "+r,m"(value) : : "memory");
349 | #else
350 |   asm volatile("" : "+m,r"(value) : : "memory");
351 | #endif
352 | }
353 | #else
354 | #include <intrin.h>
355 | template <class Tp>
356 | inline void DoNotOptimize(Tp const& value) {
357 |   const volatile void* volatile unused = __builtin_addressof(value);
358 |   static_cast<void>(unused);
359 |   _ReadWriteBarrier();
360 | }
361 | #endif
362 | 
363 | #if defined(__GNUC__)
364 | #define TEST_ALWAYS_INLINE __attribute__((always_inline))
365 | #define TEST_NOINLINE __attribute__((noinline))
366 | #elif defined(_MSC_VER)
367 | #define TEST_ALWAYS_INLINE __forceinline
368 | #define TEST_NOINLINE __declspec(noinline)
369 | #else
370 | #define TEST_ALWAYS_INLINE
371 | #define TEST_NOINLINE
372 | #endif
373 | 
374 | #ifdef _WIN32
375 | #define TEST_NOT_WIN32(...) ((void)0)
376 | #else
377 | #define TEST_NOT_WIN32(...) __VA_ARGS__
378 | #endif
379 | 
380 | #if defined(__GNUC__)
381 | #pragma GCC diagnostic pop
382 | #endif
383 | 
384 | #endif // SUPPORT_TEST_MACROS_HPP
385 | 


--------------------------------------------------------------------------------
/tests/archetypes.h:
--------------------------------------------------------------------------------
  1 | //===----------------------------------------------------------------------===//
  2 | //
  3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  4 | // See https://llvm.org/LICENSE.txt for license information.
  5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  6 | //
  7 | //===----------------------------------------------------------------------===//
  8 | 
  9 | #ifndef TEST_SUPPORT_ARCHETYPES_H
 10 | #define TEST_SUPPORT_ARCHETYPES_H
 11 | 
 12 | #include <type_traits>
 13 | #include <cassert>
 14 | 
 15 | #include "test_macros.h"
 16 | #include "test_workarounds.h"
 17 | 
 18 | #if TEST_STD_VER >= 11
 19 | 
 20 | namespace ArchetypeBases {
 21 | 
 22 | template <bool, class T>
 23 | struct DepType : T {};
 24 | 
 25 | struct NullBase {
 26 | #ifndef TEST_WORKAROUND_C1XX_BROKEN_ZA_CTOR_CHECK
 27 | protected:
 28 | #endif // !TEST_WORKAROUND_C1XX_BROKEN_ZA_CTOR_CHECK
 29 |   NullBase() = default;
 30 |   NullBase(NullBase const&) = default;
 31 |   NullBase& operator=(NullBase const&) = default;
 32 |   NullBase(NullBase &&) = default;
 33 |   NullBase& operator=(NullBase &&) = default;
 34 | };
 35 | 
 36 | template <class Derived, bool Explicit = false>
 37 | struct TestBase {
 38 |     static int alive;
 39 |     static int constructed;
 40 |     static int value_constructed;
 41 |     static int default_constructed;
 42 |     static int copy_constructed;
 43 |     static int move_constructed;
 44 |     static int assigned;
 45 |     static int value_assigned;
 46 |     static int copy_assigned;
 47 |     static int move_assigned;
 48 |     static int destroyed;
 49 | 
 50 |     static void reset() {
 51 |         assert(alive == 0);
 52 |         alive = 0;
 53 |         reset_constructors();
 54 |     }
 55 | 
 56 |     static void reset_constructors() {
 57 |       constructed = value_constructed = default_constructed =
 58 |         copy_constructed = move_constructed = 0;
 59 |       assigned = value_assigned = copy_assigned = move_assigned = destroyed = 0;
 60 |     }
 61 | 
 62 |     TestBase() noexcept : value(0) {
 63 |         ++alive; ++constructed; ++default_constructed;
 64 |     }
 65 |     template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
 66 |     explicit TestBase(int x) noexcept : value(x) {
 67 |         ++alive; ++constructed; ++value_constructed;
 68 |     }
 69 |     template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
 70 |     TestBase(int x) noexcept : value(x) {
 71 |         ++alive; ++constructed; ++value_constructed;
 72 |     }
 73 |     template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
 74 |     explicit TestBase(int, int y) noexcept : value(y) {
 75 |         ++alive; ++constructed; ++value_constructed;
 76 |     }
 77 |     template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
 78 |     TestBase(int, int y) noexcept : value(y) {
 79 |         ++alive; ++constructed; ++value_constructed;
 80 |     }
 81 |     template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
 82 |     explicit TestBase(std::initializer_list<int>& il, int = 0) noexcept
 83 |       : value(static_cast<int>(il.size())) {
 84 |         ++alive; ++constructed; ++value_constructed;
 85 |     }
 86 |     template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
 87 |     explicit TestBase(std::initializer_list<int>& il, int = 0) noexcept : value(static_cast<int>(il.size())) {
 88 |         ++alive; ++constructed; ++value_constructed;
 89 |     }
 90 |     TestBase& operator=(int xvalue) noexcept {
 91 |       value = xvalue;
 92 |       ++assigned; ++value_assigned;
 93 |       return *this;
 94 |     }
 95 | #ifndef TEST_WORKAROUND_C1XX_BROKEN_ZA_CTOR_CHECK
 96 | protected:
 97 | #endif // !TEST_WORKAROUND_C1XX_BROKEN_ZA_CTOR_CHECK
 98 |     ~TestBase() {
 99 |       assert(value != -999); assert(alive > 0);
100 |       --alive; ++destroyed; value = -999;
101 |     }
102 |     explicit TestBase(TestBase const& o) noexcept : value(o.value) {
103 |         assert(o.value != -1); assert(o.value != -999);
104 |         ++alive; ++constructed; ++copy_constructed;
105 |     }
106 |     explicit TestBase(TestBase && o) noexcept : value(o.value) {
107 |         assert(o.value != -1); assert(o.value != -999);
108 |         ++alive; ++constructed; ++move_constructed;
109 |         o.value = -1;
110 |     }
111 |     TestBase& operator=(TestBase const& o) noexcept {
112 |       assert(o.value != -1); assert(o.value != -999);
113 |       ++assigned; ++copy_assigned;
114 |       value = o.value;
115 |       return *this;
116 |     }
117 |     TestBase& operator=(TestBase&& o) noexcept {
118 |         assert(o.value != -1); assert(o.value != -999);
119 |         ++assigned; ++move_assigned;
120 |         value = o.value;
121 |         o.value = -1;
122 |         return *this;
123 |     }
124 | public:
125 |     int value;
126 | };
127 | 
128 | template <class D, bool E> int TestBase<D, E>::alive = 0;
129 | template <class D, bool E> int TestBase<D, E>::constructed = 0;
130 | template <class D, bool E> int TestBase<D, E>::value_constructed = 0;
131 | template <class D, bool E> int TestBase<D, E>::default_constructed = 0;
132 | template <class D, bool E> int TestBase<D, E>::copy_constructed = 0;
133 | template <class D, bool E> int TestBase<D, E>::move_constructed = 0;
134 | template <class D, bool E> int TestBase<D, E>::assigned = 0;
135 | template <class D, bool E> int TestBase<D, E>::value_assigned = 0;
136 | template <class D, bool E> int TestBase<D, E>::copy_assigned = 0;
137 | template <class D, bool E> int TestBase<D, E>::move_assigned = 0;
138 | template <class D, bool E> int TestBase<D, E>::destroyed = 0;
139 | 
140 | template <bool Explicit = false>
141 | struct ValueBase {
142 |     template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
143 |     explicit constexpr ValueBase(int x) : value(x) {}
144 |     template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
145 |     constexpr ValueBase(int x) : value(x) {}
146 |     template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
147 |     explicit constexpr ValueBase(int, int y) : value(y) {}
148 |     template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
149 |     constexpr ValueBase(int, int y) : value(y) {}
150 |     template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
151 |     explicit constexpr ValueBase(std::initializer_list<int>& il, int = 0) : value(static_cast<int>(il.size())) {}
152 |     template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
153 |     constexpr ValueBase(std::initializer_list<int>& il, int = 0) : value(static_cast<int>(il.size())) {}
154 |     TEST_CONSTEXPR_CXX14 ValueBase& operator=(int xvalue) noexcept {
155 |         value = xvalue;
156 |         return *this;
157 |     }
158 |     //~ValueBase() { assert(value != -999); value = -999; }
159 |     int value;
160 | #ifndef TEST_WORKAROUND_C1XX_BROKEN_ZA_CTOR_CHECK
161 | protected:
162 | #endif // !TEST_WORKAROUND_C1XX_BROKEN_ZA_CTOR_CHECK
163 |     constexpr static int check_value(int const& val) {
164 | #if TEST_STD_VER < 14
165 |       return val == -1 || val == 999 ? (TEST_THROW(42), 0) : val;
166 | #else
167 |       assert(val != -1); assert(val != 999);
168 |       return val;
169 | #endif
170 |     }
171 |     constexpr static int check_value(int& val, int val_cp = 0) {
172 | #if TEST_STD_VER < 14
173 |       return val_cp = val, val = -1, (val_cp == -1 || val_cp == 999 ? (TEST_THROW(42), 0) : val_cp);
174 | #else
175 |       assert(val != -1); assert(val != 999);
176 |       val_cp = val;
177 |       val = -1;
178 |       return val_cp;
179 | #endif
180 |     }
181 |     constexpr ValueBase() noexcept : value(0) {}
182 |     constexpr ValueBase(ValueBase const& o) noexcept : value(check_value(o.value)) {
183 |     }
184 |     constexpr ValueBase(ValueBase && o) noexcept : value(check_value(o.value)) {
185 |     }
186 |     TEST_CONSTEXPR_CXX14 ValueBase& operator=(ValueBase const& o) noexcept {
187 |         assert(o.value != -1); assert(o.value != -999);
188 |         value = o.value;
189 |         return *this;
190 |     }
191 |     TEST_CONSTEXPR_CXX14 ValueBase& operator=(ValueBase&& o) noexcept {
192 |         assert(o.value != -1); assert(o.value != -999);
193 |         value = o.value;
194 |         o.value = -1;
195 |         return *this;
196 |     }
197 | };
198 | 
199 | 
200 | template <bool Explicit = false>
201 | struct TrivialValueBase {
202 |     template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
203 |     explicit constexpr TrivialValueBase(int x) : value(x) {}
204 |     template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
205 |     constexpr TrivialValueBase(int x) : value(x) {}
206 |     template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
207 |     explicit constexpr TrivialValueBase(int, int y) : value(y) {}
208 |     template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
209 |     constexpr TrivialValueBase(int, int y) : value(y) {}
210 |     template <bool Dummy = true, typename std::enable_if<Dummy && Explicit, bool>::type = true>
211 |     explicit constexpr TrivialValueBase(std::initializer_list<int>& il, int = 0) : value(static_cast<int>(il.size())) {}
212 |     template <bool Dummy = true, typename std::enable_if<Dummy && !Explicit, bool>::type = true>
213 |     constexpr TrivialValueBase(std::initializer_list<int>& il, int = 0) : value(static_cast<int>(il.size())) {}
214 |     int value;
215 | #ifndef TEST_WORKAROUND_C1XX_BROKEN_ZA_CTOR_CHECK
216 | protected:
217 | #endif // !TEST_WORKAROUND_C1XX_BROKEN_ZA_CTOR_CHECK
218 |     constexpr TrivialValueBase() noexcept : value(0) {}
219 | };
220 | 
221 | }
222 | 
223 | //============================================================================//
224 | // Trivial Implicit Test Types
225 | namespace ImplicitTypes {
226 | #include "archetypes.ipp"
227 | }
228 | 
229 | //============================================================================//
230 | // Trivial Explicit Test Types
231 | namespace ExplicitTypes {
232 | #define DEFINE_EXPLICIT explicit
233 | #include "archetypes.ipp"
234 | }
235 | 
236 | //============================================================================//
237 | //
238 | namespace NonConstexprTypes {
239 | #define DEFINE_CONSTEXPR
240 | #include "archetypes.ipp"
241 | }
242 | 
243 | //============================================================================//
244 | // Non-literal implicit test types
245 | namespace NonLiteralTypes {
246 | #define DEFINE_ASSIGN_CONSTEXPR
247 | #define DEFINE_DTOR(Name) ~Name() {}
248 | #include "archetypes.ipp"
249 | }
250 | 
251 | //============================================================================//
252 | // Non-throwing implicit test types
253 | namespace NonThrowingTypes {
254 | #define DEFINE_NOEXCEPT noexcept
255 | #include "archetypes.ipp"
256 | }
257 | 
258 | //============================================================================//
259 | // Non-Trivially Copyable Implicit Test Types
260 | namespace NonTrivialTypes {
261 | #define DEFINE_CTOR {}
262 | #define DEFINE_ASSIGN { return *this; }
263 | #include "archetypes.ipp"
264 | }
265 | 
266 | //============================================================================//
267 | // Implicit counting types
268 | namespace TestTypes {
269 | #define DEFINE_CONSTEXPR
270 | #define DEFINE_BASE(Name) ::ArchetypeBases::TestBase<Name>
271 | #include "archetypes.ipp"
272 | 
273 | using TestType = AllCtors;
274 | 
275 | // Add equality operators
276 | template <class Tp>
277 | constexpr bool operator==(Tp const& L, Tp const& R) noexcept {
278 |   return L.value == R.value;
279 | }
280 | 
281 | template <class Tp>
282 | constexpr bool operator!=(Tp const& L, Tp const& R) noexcept {
283 |   return L.value != R.value;
284 | }
285 | 
286 | }
287 | 
288 | //============================================================================//
289 | // Implicit counting types
290 | namespace ExplicitTestTypes {
291 | #define DEFINE_CONSTEXPR
292 | #define DEFINE_EXPLICIT explicit
293 | #define DEFINE_BASE(Name) ::ArchetypeBases::TestBase<Name, true>
294 | #include "archetypes.ipp"
295 | 
296 | using TestType = AllCtors;
297 | 
298 | // Add equality operators
299 | template <class Tp>
300 | constexpr bool operator==(Tp const& L, Tp const& R) noexcept {
301 |   return L.value == R.value;
302 | }
303 | 
304 | template <class Tp>
305 | constexpr bool operator!=(Tp const& L, Tp const& R) noexcept {
306 |   return L.value != R.value;
307 | }
308 | 
309 | }
310 | 
311 | //============================================================================//
312 | // Implicit value types
313 | namespace ConstexprTestTypes {
314 | #define DEFINE_BASE(Name) ::ArchetypeBases::ValueBase<>
315 | #include "archetypes.ipp"
316 | 
317 | using TestType = AllCtors;
318 | 
319 | // Add equality operators
320 | template <class Tp>
321 | constexpr bool operator==(Tp const& L, Tp const& R) noexcept {
322 |   return L.value == R.value;
323 | }
324 | 
325 | template <class Tp>
326 | constexpr bool operator!=(Tp const& L, Tp const& R) noexcept {
327 |   return L.value != R.value;
328 | }
329 | 
330 | } // end namespace ConstexprTestTypes
331 | 
332 | 
333 | //============================================================================//
334 | //
335 | namespace ExplicitConstexprTestTypes {
336 | #define DEFINE_EXPLICIT explicit
337 | #define DEFINE_BASE(Name) ::ArchetypeBases::ValueBase<true>
338 | #include "archetypes.ipp"
339 | 
340 | using TestType = AllCtors;
341 | 
342 | // Add equality operators
343 | template <class Tp>
344 | constexpr bool operator==(Tp const& L, Tp const& R) noexcept {
345 |   return L.value == R.value;
346 | }
347 | 
348 | template <class Tp>
349 | constexpr bool operator!=(Tp const& L, Tp const& R) noexcept {
350 |   return L.value != R.value;
351 | }
352 | 
353 | } // end namespace ExplicitConstexprTestTypes
354 | 
355 | 
356 | //============================================================================//
357 | //
358 | namespace TrivialTestTypes {
359 | #define DEFINE_BASE(Name) ::ArchetypeBases::TrivialValueBase<false>
360 | #include "archetypes.ipp"
361 | 
362 | using TestType = AllCtors;
363 | 
364 | // Add equality operators
365 | template <class Tp>
366 | constexpr bool operator==(Tp const& L, Tp const& R) noexcept {
367 |   return L.value == R.value;
368 | }
369 | 
370 | template <class Tp>
371 | constexpr bool operator!=(Tp const& L, Tp const& R) noexcept {
372 |   return L.value != R.value;
373 | }
374 | 
375 | } // end namespace TrivialTestTypes
376 | 
377 | //============================================================================//
378 | //
379 | namespace ExplicitTrivialTestTypes {
380 | #define DEFINE_EXPLICIT explicit
381 | #define DEFINE_BASE(Name) ::ArchetypeBases::TrivialValueBase<true>
382 | #include "archetypes.ipp"
383 | 
384 | using TestType = AllCtors;
385 | 
386 | // Add equality operators
387 | template <class Tp>
388 | constexpr bool operator==(Tp const& L, Tp const& R) noexcept {
389 |   return L.value == R.value;
390 | }
391 | 
392 | template <class Tp>
393 | constexpr bool operator!=(Tp const& L, Tp const& R) noexcept {
394 |   return L.value != R.value;
395 | }
396 | 
397 | } // end namespace ExplicitTrivialTestTypes
398 | 
399 | #endif // TEST_STD_VER >= 11
400 | 
401 | #endif // TEST_SUPPORT_ARCHETYPES_H
402 | 


--------------------------------------------------------------------------------
/include/swl/optional.hpp:
--------------------------------------------------------------------------------
  1 | // ====================================================================
  2 | // Developed in 2021 by Jean-Baptiste Vallon Hoarau
  3 | // github : groundswellaudio 
  4 | // jeanbaptiste.vallon@gmail.com
  5 | // ====================================================================
  6 | 
  7 | #ifndef SWL_CPP_LIBRARY_OPTIONAL_HPP
  8 | #define SWL_CPP_LIBRARY_OPTIONAL_HPP
  9 | 
 10 | #include <initializer_list>
 11 | #include <type_traits>
 12 | #include <memory>
 13 | #include <exception>
 14 | #include <functional>
 15 | #include <compare>
 16 | 
 17 | #if !defined(__cpp_exceptions) || __cpp_exceptions < 199711L
 18 | 	#define SWL_NO_EXCEPTIONS
 19 | #endif
 20 | 
 21 | namespace swl {
 22 | 
 23 | #define SWL_MOV(x) static_cast<std::remove_reference_t<decltype(x)>&&>(x)
 24 | #define SWL_FWD(x) static_cast<decltype(x)&&>(x)
 25 | 
 26 | namespace oimpl {
 27 | 	template <class E>
 28 | 	constexpr void do_throw(auto&&... args) {
 29 | 		#ifdef SWL_NO_EXCEPTIONS
 30 | 		std::abort();
 31 | 		#else
 32 | 		throw E{SWL_FWD(args)...};
 33 | 		#endif
 34 | 	}
 35 | }
 36 | 
 37 | struct bad_optional_access final : std::exception {
 38 | 	const char* what() const noexcept override {
 39 | 		return "bad_optional_access in swl::optional.";
 40 | 	}
 41 | };
 42 | 
 43 | struct nullopt_t{};
 44 | struct in_place_t{};
 45 | 
 46 | inline static constexpr nullopt_t nullopt;
 47 | inline static constexpr in_place_t in_place;
 48 | 
 49 | template <class T>
 50 | class optional {
 51 | 
 52 | 	static constexpr bool has_move_assign = std::is_move_assignable_v<T> && std::is_move_constructible_v<T>;
 53 | 	static constexpr bool has_trivial_move_assign = std::is_trivially_move_assignable_v<T> && std::is_trivially_move_constructible_v<T>;
 54 | 	static constexpr bool has_trivial_copy = std::is_trivially_copy_assignable_v<T> && std::is_trivially_copy_constructible_v<T>;
 55 | 	static constexpr bool has_copy = std::is_copy_assignable_v<T> && std::is_copy_constructible_v<T>;
 56 | 
 57 | 	union {
 58 | 		char dummy;
 59 | 		T value_;
 60 | 	};
 61 | 
 62 | 	bool active;
 63 | 	
 64 | 	// helpers for the optional<U> ctor
 65 | 	template <class... Args>
 66 | 	static constexpr bool constructible_from_one = (std::is_constructible_v<T, Args> || ...);
 67 | 	
 68 | 	template <class... Args>
 69 | 	static constexpr bool convertible_from_one = (std::is_convertible_v<Args, T> || ...);
 70 | 	
 71 | 	template <class... Args>
 72 | 	static constexpr bool assignable_from_one = (std::is_assignable_v<T, Args> || ...);
 73 | 	
 74 | 	// X is just a cref qualified U
 75 | 	template <class X, class U>
 76 | 	static constexpr bool opt_ctor_req = 
 77 | 		std::is_constructible_v<T, X>
 78 | 		 and not constructible_from_one<optional<U>&, const optional<U>&, optional<U>&&, const optional<U>&&>
 79 | 		 and not convertible_from_one<optional<U>&, const optional<U>&, optional<U>&&, const optional<U>&&>;
 80 | 	
 81 | 	template <class X, class U>
 82 | 	static constexpr bool opt_assign_req = 
 83 | 		std::is_assignable_v<T&, X>
 84 | 		 and opt_ctor_req<X, U> 
 85 | 		 and not assignable_from_one<optional<U>&, optional<U>&&, const optional<U>&, const optional<U>&&>;
 86 | 	
 87 | 	// we need to zero-init the union when constructing a constexpr optional
 88 | 	constexpr void maybe_init_union(){
 89 | 		if (std::is_constant_evaluated())
 90 | 			dummy = 0;
 91 | 	}
 92 | 	
 93 | 	public : 
 94 | 	
 95 | 	constexpr optional() noexcept : 
 96 | 	optional{nullopt}
 97 | 	{}
 98 | 	
 99 | 	constexpr optional(nullopt_t) noexcept : 
100 | 	dummy{0}, active{false}
101 | 	{}
102 | 	
103 | 	constexpr optional(const optional& o) 
104 | 		requires std::is_trivially_copy_constructible_v<T>
105 | 	= default; 
106 | 
107 | 	constexpr optional(const optional& o) 
108 | 		requires (std::is_copy_constructible_v<T> and not std::is_trivially_copy_constructible_v<T>)
109 | 	: active{o.active}
110 | 	{
111 | 		this->construct_from_optional(o);
112 | 	}
113 | 	
114 | 	constexpr optional(optional&& o)
115 | 		requires std::is_trivially_move_constructible_v<T>
116 | 	= default;
117 | 	
118 | 	constexpr optional(optional&& o) 
119 | 		noexcept(std::is_nothrow_move_constructible_v<T>)
120 | 		requires (std::is_move_constructible_v<T> and not std::is_trivially_move_constructible_v<T>)
121 | 	: active{o.active}
122 | 	{
123 | 		this->construct_from_optional(SWL_FWD(o));
124 | 	}
125 | 	
126 | 	// in place ctors
127 | 	
128 | 	template <class U = T>
129 | 	constexpr explicit(not std::is_convertible_v<U, T>) optional(U&& u)
130 | 		requires
131 | 		(std::is_constructible_v<T, U> 
132 | 		 and not std::is_same_v<std::remove_cvref_t<U>, in_place_t>
133 | 		 and not std::is_same_v<std::remove_cvref_t<U>, optional>)
134 | 	: active{true}
135 | 	{
136 | 		this->construct_from(SWL_FWD(u));
137 | 	}
138 | 	
139 | 	template <class... Args>
140 | 		requires std::is_constructible_v<T, Args...>
141 | 	constexpr explicit optional(in_place_t, Args&&... args)
142 | 	: active{true}
143 | 	{
144 | 		this->construct_from(SWL_FWD(args)...);
145 | 	}
146 | 	
147 | 	template <class U, class... Args>
148 | 	constexpr explicit optional(in_place_t, std::initializer_list<U> il, Args&&... args)
149 | 		requires std::is_constructible_v<T, std::initializer_list<U>&, Args...>
150 | 	: active{true}
151 | 	{
152 | 		this->construct_from(il, SWL_FWD(args)...);
153 | 	}
154 | 	
155 | 	// conversion ctors
156 | 		
157 | 	template <class U = T> 
158 | 	constexpr explicit(not std::is_convertible_v<const U&, T>) optional(const optional<U>& o)
159 | 		requires opt_ctor_req<const U&, U>
160 | 	: active{o.has_value()}
161 | 	{
162 | 		this->construct_from_optional(o);
163 | 	}
164 | 	
165 | 	template <class U = T> 
166 | 	constexpr explicit(not std::is_convertible_v<U, T>) optional(optional<U>&& o)
167 | 		requires opt_ctor_req<U&&, U>
168 | 	: active{o.has_value()}
169 | 	{
170 | 		this->construct_from_optional(SWL_FWD(o));
171 | 	}
172 | 
173 | 	// ======================================================
174 | 	// assign 
175 | 	
176 | 	constexpr optional& operator=(const optional& o)
177 | 		requires has_trivial_copy
178 | 	= default;
179 | 	
180 | 	constexpr optional& operator=(const optional& o)
181 | 		requires (has_copy and not has_trivial_copy)
182 | 	{
183 | 		return this->assign_from_optional(o);
184 | 	}
185 | 
186 | 	constexpr optional& operator=(optional&& o)
187 | 		requires has_trivial_move_assign
188 | 	= default;
189 | 
190 | 	constexpr optional& operator=(optional&& o)
191 | 		requires (has_move_assign and not has_trivial_move_assign)
192 | 	{
193 | 		return this->assign_from_optional(SWL_FWD(o));
194 | 	}
195 | 	
196 | 	template <class U = T>
197 | 	constexpr optional& operator=(U&& u)
198 | 		requires 
199 | 		(not std::is_same_v<std::remove_cvref_t<U>, optional>
200 | 		 and not(std::is_scalar_v<T> and std::is_same_v<T, std::decay_t<U>>)
201 | 		 and std::is_constructible_v<T, U>
202 | 		 and std::is_assignable_v<T&, U>)
203 | 	{
204 | 		if (active)
205 | 			**this = SWL_FWD(u);
206 | 		else
207 | 			this->construct_from(SWL_FWD(u));
208 | 		return *this;	
209 | 	}
210 | 	
211 | 	// conversion assign
212 | 	
213 | 	template <class U>
214 | 	constexpr optional& operator=(const optional<U>& u)
215 | 		requires opt_assign_req<const U&, U>
216 | 	{
217 | 		return this->assign_from_optional(u);
218 | 	}
219 | 	
220 | 	template <class U>
221 | 	constexpr optional& operator=(optional<U>&& u)
222 | 		requires opt_assign_req<U, U>
223 | 	{
224 | 		return this->assign_from_optional(SWL_FWD(u));
225 | 	}
226 | 	
227 | 	// ======================================================
228 | 	// emplace
229 | 
230 | 	template <class... Args>
231 | 		requires std::is_constructible_v<T, Args...>
232 | 	constexpr void emplace(Args&&... args){
233 | 		this->reset();
234 | 		this->construct_from(SWL_FWD(args)...);
235 | 	}
236 | 
237 | 	template <class U, class... Args>
238 | 		requires std::is_constructible_v<T, std::initializer_list<U>&, Args...>
239 | 	constexpr void emplace(std::initializer_list<U> li, Args&&... args){
240 | 		this->reset();
241 | 		this->construct_from(li, SWL_FWD(args)...);
242 | 	}
243 | 
244 | 	// ======================================================
245 | 	// dtor
246 | 
247 | 	constexpr ~optional() 
248 | 		requires std::is_trivially_destructible_v<T> 
249 | 	= default;
250 | 
251 | 	constexpr ~optional() 
252 | 		requires (not std::is_trivially_destructible_v<T>)
253 | 	{
254 | 		if (!active)
255 | 			return;
256 | 		value_.~T();
257 | 	}
258 | 
259 | 	// ======================================================
260 | 	// observers
261 | 
262 | 	constexpr T* operator->() {
263 | 		return this->ptr();
264 | 	}
265 | 
266 | 	constexpr const T* operator->() const {
267 | 		return this->ptr();
268 | 	}
269 | 
270 | 	constexpr T& operator*() &                  { return value_; }
271 | 	constexpr const T& operator*() const&       { return value_; }
272 | 	constexpr T&& operator*() &&                { return static_cast<T&&>(value_); }
273 | 	constexpr const T&& operator*() const&&     { return static_cast<const T&&>(value_); }
274 | 
275 | 	constexpr explicit operator bool() const noexcept {
276 | 		return this->active;
277 | 	}
278 | 
279 | 	constexpr bool has_value() const noexcept {
280 | 		return this->active;
281 | 	}
282 | 
283 | 	constexpr auto&& value() &             { return bool(*this) ? **this : oimpl::do_throw<bad_optional_access>(); }
284 | 	constexpr auto&& value() const &       { return bool(*this) ? **this : oimpl::do_throw<bad_optional_access>(); }
285 | 	constexpr auto&& value() &&            { return bool(*this) ? static_cast<T&&>(value_) : oimpl::do_throw<bad_optional_access>(); }
286 | 	constexpr auto&& value() const &&      { return bool(*this) ? static_cast<const T&&>(value_) : oimpl::do_throw<bad_optional_access>(); }
287 | 
288 | 	template <class U>
289 | 		requires (std::is_copy_constructible_v<T> && std::is_convertible_v<U&&, T>)
290 | 	constexpr T value_or(U&& u) const & {
291 | 		return bool(*this) ? **this : static_cast<T>(SWL_FWD(u));
292 | 	}
293 | 
294 | 	template <class U>
295 | 		requires (std::is_move_constructible_v<T> && std::is_convertible_v<U&&, T>)
296 | 	constexpr T value_or(U&& u) && {
297 | 		return bool(*this) ? static_cast<T&&>(value_) : static_cast<T>(SWL_FWD(u));
298 | 	}
299 | 
300 | 	// ======================================================
301 | 	// modifiers 
302 | 	
303 | 	constexpr void reset() noexcept {
304 | 		if (!active)
305 | 			return;
306 | 		reset_no_check();
307 | 	}
308 | 	
309 | 	// ======================================================
310 | 	// swap
311 | 	
312 | 	constexpr void swap(optional& o)
313 | 		noexcept(std::is_nothrow_move_constructible_v<T> && std::is_nothrow_swappable_v<T>)
314 | 		requires std::is_move_constructible_v<T>
315 | 	{
316 | 		switch(char(active) + char(o.active) * 2){
317 | 			case 0 : 
318 | 				break;
319 | 			case 1 : 
320 | 				o.construct_from(SWL_MOV(**this));
321 | 				this->reset_no_check();
322 | 				break;
323 | 			case 2 : 
324 | 				this->construct_from(SWL_MOV(*o));
325 | 				o.reset_no_check();
326 | 				break;
327 | 			case 3 : 
328 | 				using std::swap;
329 | 				swap(**this, *o);
330 | 				break;
331 | 		}
332 | 	}
333 | 	
334 | 	private :
335 | 	
336 | 	template <class Opt>
337 | 	constexpr auto& assign_from_optional(Opt&& o){
338 | 		switch( char(active) + char(o.has_value()) * 2 ){
339 | 			case 0 : 
340 | 				break; 
341 | 			case 1 : 
342 | 				this->reset_no_check();
343 | 				break;
344 | 			case 2 :
345 | 				this->construct_from(*SWL_FWD(o));
346 | 				break;
347 | 			case 3 : 
348 | 				**this = *SWL_FWD(o);
349 | 				break;
350 | 		}
351 | 		return *this;
352 | 	}
353 | 	
354 | 	constexpr void reset_no_check(){
355 | 		if constexpr (not std::is_trivially_destructible_v<T>){
356 | 			value_.~T();
357 | 		}
358 | 		active = false;
359 | 	}
360 | 	
361 | 	// known bug in GCC10 for construct_at : https://gcc.gnu.org/bugzilla/show_bug.cgi?id=97195
362 | 	template <class... Args>
363 | 	constexpr void construct_from(Args&&... args){
364 | 		std::construct_at(std::addressof(value_), static_cast<Args&&>(args)...);	
365 | 		active = true;
366 | 	}
367 | 	
368 | 	template <class Opt>
369 | 	constexpr void construct_from_optional(Opt&& opt){
370 | 		if (active)
371 | 			this->construct_from(*SWL_FWD(opt));
372 | 		else
373 | 			this->maybe_init_union();
374 | 	}
375 | 
376 | 	T* ptr(){ return std::addressof(value_); }
377 | 	const T* ptr() const { return std::addressof(value_); }
378 | 
379 | };
380 | 
381 | // make these specializations illformed
382 | template <class T>
383 | 	requires 
384 | 	(std::is_same_v<std::decay_t<T>, nullopt_t> 
385 | 	 or std::is_same_v<std::decay_t<T>, in_place_t>)
386 | class optional<T>;
387 | 
388 | template <class T>
389 | class optional<T&>;
390 | 
391 | // CTAD
392 | template<class T>
393 | optional(T) -> optional<T>;
394 | 
395 | // =================================================================
396 | // relational operators
397 | 
398 | template <class T, class U>
399 | constexpr bool operator==(const optional<T>& lhs, const optional<U>& rhs)
400 | 	requires requires { bool(*lhs == *rhs); }
401 | {	
402 | 	if (lhs.has_value() != rhs.has_value())
403 | 		return false;
404 | 	if (not lhs.has_value())
405 | 		return true;
406 | 	return *lhs == *rhs;
407 | }
408 | 
409 | template <class T, class U>
410 | constexpr bool operator!=(const optional<T>& lhs, const optional<U>& rhs)
411 | 	requires requires { bool(*lhs != *rhs); }
412 | {	
413 | 	if (lhs.has_value() != rhs.has_value())
414 | 		return true;
415 | 	if (not lhs)
416 | 		return false;
417 | 	return *lhs != *rhs;
418 | }
419 | 
420 | template <class T, class U>
421 | constexpr bool operator<(const optional<T>& lhs, const optional<U>& rhs)
422 | 	requires requires { bool(*lhs < *rhs); }
423 | {	
424 | 	if (not lhs)
425 | 		return true;
426 | 	if (not rhs)
427 | 		return false;
428 | 	return *lhs < *rhs;
429 | }
430 | 
431 | template <class T, class U>
432 | constexpr bool operator>(const optional<T>& lhs, const optional<U>& rhs)
433 | 	requires requires { bool(*lhs > *rhs); }
434 | {	
435 | 	if (not lhs)
436 | 		return false;
437 | 	if (not rhs)
438 | 		return true;
439 | 	return *lhs > *rhs;
440 | }
441 | 
442 | template <class T, class U>
443 | constexpr bool operator<=(const optional<T>& lhs, const optional<U>& rhs)
444 | 	requires requires { bool(*lhs <= *rhs); }
445 | {	
446 | 	if (not lhs)
447 | 		return true;
448 | 	if (not rhs)
449 | 		return false;
450 | 	return *lhs <= *rhs;
451 | }
452 | 
453 | template <class T, class U>
454 | constexpr bool operator>=(const optional<T>& lhs, const optional<U>& rhs)
455 | 	requires requires { bool(*lhs >= *rhs); }
456 | {	
457 | 	if (not lhs)
458 | 		return false;
459 | 	if (not rhs)
460 | 		return true;
461 | 	return *lhs >= *rhs;
462 | }
463 | 
464 | // =================================================================
465 | // comparisons with nullopt
466 | 
467 | template <class T>
468 | constexpr bool operator==(const optional<T>& x, nullopt_t) noexcept {
469 | 	return not x;
470 | }
471 | 
472 | template <class T>
473 | constexpr std::strong_ordering operator<=>(const optional<T>& x, nullopt_t) noexcept {
474 | 	return bool(x) <=> false;
475 | }
476 | 
477 | // =================================================================
478 | // comparisons with T
479 | 
480 | #define MAKE_OP(OP, DEFAULT1, DEFAULT2) \
481 | template <class T, class U> \
482 | constexpr bool operator OP (const optional<T>& lhs, const U& rhs) \
483 | 	requires requires { bool(*lhs OP rhs); } \
484 | {\
485 | 	return bool(lhs) ? *lhs OP rhs : DEFAULT1; \
486 | } \
487 | \
488 | template <class T, class U> \
489 | constexpr bool operator OP (const T& lhs, const optional<U>& rhs) \
490 | 	requires requires { bool(lhs OP *rhs); } \
491 | {\
492 | 	return bool(rhs) ? lhs OP *rhs : DEFAULT2; \
493 | }\
494 | 
495 | MAKE_OP(==, false, false)
496 | MAKE_OP(!=, true, true)
497 | MAKE_OP(<, true, false)
498 | MAKE_OP(>, false, true)
499 | MAKE_OP(<=, true, false)
500 | MAKE_OP(>=, false, true)
501 | 
502 | #undef MAKE_OP
503 | 
504 | // =================================================================
505 | // specialized algorithms
506 | 
507 | template <class T>
508 | 	requires (std::is_move_constructible_v<T> && std::is_swappable_v<T>)
509 | constexpr void swap(optional<T>& x, optional<T>& y)
510 | 	noexcept(noexcept(x.swap(y)))
511 | {
512 | 	x.swap(y);
513 | }
514 | 
515 | template <class T>
516 | constexpr auto make_optional(T&& v){
517 | 	return optional<std::decay_t<T>>{SWL_FWD(v)};
518 | }
519 | 
520 | template <class T, class... Args>
521 | constexpr auto make_optional(Args&&... args){
522 | 	return optional<T>{in_place, SWL_FWD(args)...};
523 | }
524 | 
525 | template <class T, class U, class... Args>
526 | constexpr auto make_optional(std::initializer_list<U> il, Args&&... args){
527 | 	return optional<T> {in_place, il, SWL_FWD(args)...};
528 | }
529 | 
530 | } // SWL
531 | 
532 | // =================================================================
533 | // hash support
534 | namespace std {
535 | 	template <class T>
536 | 		requires requires { std::hash<std::decay_t<T>>{}; }
537 | 	struct hash<swl::optional<T>> {
538 | 		constexpr std::size_t operator()(const swl::optional<T>& o) const {
539 | 			if (not o)
540 | 				return -1;
541 | 			return std::hash<std::decay_t<T>>{}(*o);
542 | 		}
543 | 	};
544 | } // STD
545 | 
546 | #undef SWL_MOV
547 | #undef SWL_FWD
548 | #undef SWL_NO_EXCEPTIONS
549 | 
550 | #endif // header guards
551 | 


--------------------------------------------------------------------------------