├── .gitattributes
├── test
    ├── iter.cpp
    ├── range.cpp
    ├── result.cpp
    ├── test.cpp
    ├── slice.cpp
    ├── option.cpp
    ├── raii_checker.hpp
    ├── function.cpp
    ├── cmp.cpp
    ├── enum.cpp
    └── tuple.cpp
├── README.md
├── .gitignore
├── CMakeLists.txt.in
├── include
    └── crust
    │   ├── fmt
    │       └── mod.hpp
    │   ├── ops
    │       ├── mod.hpp
    │       ├── range.hpp
    │       └── function.hpp
    │   ├── clone.hpp
    │   ├── iter
    │       └── mod.hpp
    │   ├── slice.hpp
    │   ├── option.hpp
    │   ├── result.hpp
    │   ├── helper
    │       ├── repeat_macro.hpp
    │       └── types.hpp
    │   ├── enum.hpp
    │   ├── option_decl.hpp
    │   ├── num
    │       └── mod.hpp
    │   ├── cmp_decl.hpp
    │   ├── tuple.hpp
    │   ├── cmp.hpp
    │   ├── tuple_decl.hpp
    │   ├── utility.hpp
    │   └── enum_decl.hpp
├── .github
    └── workflows
    │   ├── test-clang.yml
    │   ├── test-gcc.yml
    │   └── test-msvc.yml
├── .clang-tidy
├── LICENSE
├── CMakeLists.txt
└── .clang-format


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


--------------------------------------------------------------------------------
/test/iter.cpp:
--------------------------------------------------------------------------------
1 | #include "gtest/gtest.h"
2 | 
3 | #include "crust/iter/mod.hpp"
4 | 
5 | using namespace crust;
6 | 
7 | 
8 | GTEST_TEST(iter, iter) {}
9 | 


--------------------------------------------------------------------------------
/test/range.cpp:
--------------------------------------------------------------------------------
1 | #include "gtest/gtest.h"
2 | 
3 | #include "crust/ops/range.hpp"
4 | 
5 | using namespace crust;
6 | 
7 | 
8 | GTEST_TEST(range, range) {}
9 | 


--------------------------------------------------------------------------------
/test/result.cpp:
--------------------------------------------------------------------------------
1 | #include "gtest/gtest.h"
2 | 
3 | #include "crust/result.hpp"
4 | 
5 | using namespace crust;
6 | 
7 | 
8 | GTEST_TEST(result, result) {}
9 | 


--------------------------------------------------------------------------------
/test/test.cpp:
--------------------------------------------------------------------------------
1 | #include "gtest/gtest.h"
2 | 
3 | 
4 | int main(int argc, char **argv) {
5 |   ::testing::InitGoogleTest(&argc, argv);
6 |   return RUN_ALL_TESTS();
7 | }
8 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # crust
2 | 
3 | A Rust style C++ library.
4 | 
5 | ![](https://github.com/Cytosine2020/crust/actions/workflows/test-gcc.yml/badge.svg)
6 | ![](https://github.com/Cytosine2020/crust/actions/workflows/test-clang.yml/badge.svg)
7 | ![](https://github.com/Cytosine2020/crust/actions/workflows/test-msvc.yml/badge.svg)


--------------------------------------------------------------------------------
/test/slice.cpp:
--------------------------------------------------------------------------------
 1 | #include "gtest/gtest.h"
 2 | 
 3 | #include "crust/slice.hpp"
 4 | #include "crust/utility.hpp"
 5 | 
 6 | 
 7 | using namespace crust;
 8 | 
 9 | 
10 | GTEST_TEST(slice, slice) {
11 |   constexpr usize BUFFER_SIZE = 10;
12 | 
13 |   u8 buffer[BUFFER_SIZE]{};
14 | 
15 |   auto slice = Slice<u8>::from_raw_parts(buffer, BUFFER_SIZE);
16 | 
17 |   EXPECT_EQ(slice[1], 0);
18 | }
19 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Prerequisites
 2 | *.d
 3 | 
 4 | # Compiled Object files
 5 | *.slo
 6 | *.lo
 7 | *.o
 8 | *.obj
 9 | 
10 | # Precompiled Headers
11 | *.gch
12 | *.pch
13 | 
14 | # Compiled Dynamic libraries
15 | *.so
16 | *.dylib
17 | *.dll
18 | 
19 | # Fortran module files
20 | *.mod
21 | *.smod
22 | 
23 | # Compiled Static libraries
24 | *.lai
25 | *.la
26 | *.a
27 | *.lib
28 | 
29 | # Executables
30 | *.exe
31 | *.out
32 | *.app
33 | 
34 | .idea/
35 | .vscode/
36 | .vs/
37 | 
38 | build/
39 | cmake-build-*/
40 | out/
41 | 


--------------------------------------------------------------------------------
/CMakeLists.txt.in:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required(VERSION 2.8.12)
 2 | 
 3 | project(googletest-download NONE)
 4 | 
 5 | include(ExternalProject)
 6 | ExternalProject_Add(googletest
 7 |   GIT_REPOSITORY    https://github.com/google/googletest.git
 8 |   GIT_TAG           main
 9 |   SOURCE_DIR        "${CMAKE_CURRENT_BINARY_DIR}/googletest-src"
10 |   BINARY_DIR        "${CMAKE_CURRENT_BINARY_DIR}/googletest-build"
11 |   CONFIGURE_COMMAND ""
12 |   BUILD_COMMAND     ""
13 |   INSTALL_COMMAND   ""
14 |   TEST_COMMAND      ""
15 | )
16 | 


--------------------------------------------------------------------------------
/include/crust/fmt/mod.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef CRUST_FMT_MOD_HPP
 2 | #define CRUST_FMT_MOD_HPP
 3 | 
 4 | 
 5 | #include "crust/utility.hpp"
 6 | 
 7 | 
 8 | namespace crust {
 9 | namespace fmt {
10 | struct Formatter {};
11 | 
12 | CRUST_TRAIT(Debug) {
13 |   CRUST_TRAIT_USE_SELF(Debug);
14 | 
15 |   bool fmt_debug(Formatter & fmt);
16 | };
17 | 
18 | CRUST_TRAIT(Display) {
19 |   CRUST_TRAIT_USE_SELF(Display);
20 | 
21 |   bool fmt_display(Formatter & fmt);
22 | };
23 | } // namespace fmt
24 | } // namespace crust
25 | 
26 | 
27 | #endif // CRUST_FMT_MOD_HPP
28 | 


--------------------------------------------------------------------------------
/include/crust/ops/mod.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef CRUST_OPS_MOD_HPP
 2 | #define CRUST_OPS_MOD_HPP
 3 | 
 4 | 
 5 | #include "crust/utility.hpp"
 6 | 
 7 | 
 8 | namespace crust {
 9 | namespace index {
10 | CRUST_TRAIT(Index, class Idx, class T) {
11 |   CRUST_TRAIT_USE_SELF(Index);
12 | 
13 |   const T &index(Idx idx) const;
14 | 
15 |   T &index_mut(Idx idx);
16 | 
17 |   const T &operator[](Idx idx) const { return self().index(idx); }
18 | 
19 |   T &operator[](Idx idx) { return self().index_mut(idx); }
20 | };
21 | } // namespace index
22 | } // namespace crust
23 | 
24 | 
25 | #endif // CRUST_OPS_MOD_HPP
26 | 


--------------------------------------------------------------------------------
/include/crust/clone.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef CRUST_CLONE_HPP
 2 | #define CRUST_CLONE_HPP
 3 | 
 4 | 
 5 | #include "crust/utility.hpp"
 6 | 
 7 | 
 8 | namespace crust {
 9 | 
10 | namespace clone {
11 | template <class T>
12 | T clone(const T &self) {
13 |   return self.clone();
14 | }
15 | 
16 | CRUST_TRAIT(Clone) {
17 |   CRUST_TRAIT_USE_SELF(Clone);
18 | 
19 |   Self clone() const { return *static_cast<const Self *>(this); }
20 | 
21 |   void clone_from(const Self &other) {
22 |     *static_cast<Self *>(this) = clone::clone(other);
23 |   }
24 | };
25 | } // namespace clone
26 | } // namespace crust
27 | 
28 | 
29 | #endif // CRUST_CLONE_HPP
30 | 


--------------------------------------------------------------------------------
/include/crust/ops/range.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef CRUST_OPS_RANGE_HPP
 2 | #define CRUST_OPS_RANGE_HPP
 3 | 
 4 | 
 5 | #include "crust/enum.hpp"
 6 | #include "crust/utility.hpp"
 7 | 
 8 | 
 9 | namespace crust {
10 | namespace range {
11 | struct RangeFull {};
12 | 
13 | template <class T>
14 | struct Range {
15 |   T start;
16 |   T end;
17 | 
18 |   constexpr Range(T start, T end) : start{start}, end{end} {}
19 | 
20 |   constexpr bool is_empty() const { return start >= end; }
21 | };
22 | 
23 | template <class T>
24 | struct RangeFrom {
25 |   T start;
26 | 
27 |   explicit constexpr RangeFrom(T start) : start{start} {}
28 | };
29 | 
30 | template <class T>
31 | struct RangeTo {
32 |   T end;
33 | 
34 |   explicit constexpr RangeTo(T end) : end{end} {}
35 | };
36 | } // namespace range
37 | } // namespace crust
38 | 
39 | 
40 | #endif // CRUST_OPS_RANGE_HPP
41 | 


--------------------------------------------------------------------------------
/.github/workflows/test-clang.yml:
--------------------------------------------------------------------------------
 1 | name: test-clang
 2 | 
 3 | on: push
 4 | 
 5 | jobs:
 6 |   test:
 7 |     runs-on: macos-latest
 8 | 
 9 |     strategy:
10 |       fail-fast: false
11 |       matrix:
12 |         build: [Debug, Release]
13 |         standard: [cxx11, cxx14, cxx17, cxx20]
14 | 
15 |     defaults:
16 |       run:
17 |         shell: bash
18 | 
19 |     name: "${{matrix.standard}}-${{matrix.build}}"
20 |     steps:
21 |     - uses: actions/checkout@v2
22 | 
23 |     - name: configure cmake
24 |       run: cmake -S $GITHUB_WORKSPACE -B ${{runner.workspace}}/build -DCMAKE_BUILD_TYPE=${{matrix.build}}
25 | 
26 |     - name: build
27 |       working-directory: ${{runner.workspace}}/build
28 |       run: cmake --build . --config ${{matrix.build}} --target test-${{matrix.standard}}
29 | 
30 |     - name: test
31 |       working-directory: ${{runner.workspace}}/build
32 |       run: ./test-${{matrix.standard}} -V
33 | 


--------------------------------------------------------------------------------
/.github/workflows/test-gcc.yml:
--------------------------------------------------------------------------------
 1 | name: test-gcc
 2 | 
 3 | on: push
 4 | 
 5 | jobs:
 6 |   test:
 7 |     runs-on: ubuntu-latest
 8 | 
 9 |     strategy:
10 |       fail-fast: false
11 |       matrix:
12 |         build: [Debug, Release]
13 |         standard: [cxx11, cxx14, cxx17, cxx20]
14 | 
15 |     defaults:
16 |       run:
17 |         shell: bash
18 | 
19 |     name: "${{matrix.standard}}-${{matrix.build}}"
20 |     steps:
21 |     - uses: actions/checkout@v2
22 | 
23 |     - name: configure cmake
24 |       run: cmake -S $GITHUB_WORKSPACE -B ${{runner.workspace}}/build -DCMAKE_BUILD_TYPE=${{matrix.build}}
25 | 
26 |     - name: build
27 |       working-directory: ${{runner.workspace}}/build
28 |       run: cmake --build . --config ${{matrix.build}} --target test-${{matrix.standard}}
29 | 
30 |     - name: test
31 |       working-directory: ${{runner.workspace}}/build
32 |       run: ./test-${{matrix.standard}} -V
33 | 


--------------------------------------------------------------------------------
/include/crust/iter/mod.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef CRUST_ITER_MOD_HPP
 2 | #define CRUST_ITER_MOD_HPP
 3 | 
 4 | 
 5 | #include "crust/enum.hpp"
 6 | #include "crust/option.hpp"
 7 | #include "crust/tuple.hpp"
 8 | #include "crust/utility.hpp"
 9 | 
10 | 
11 | namespace crust {
12 | namespace iter {
13 | CRUST_TRAIT(Iterator, class Item) {
14 |   CRUST_TRAIT_USE_SELF(Iterator);
15 | 
16 |   Option<Item> next();
17 | 
18 |   constexpr Tuple<usize, Option<usize>> size_hint() const {
19 |     return tuple<usize, Option<usize>>(0, None{});
20 |   }
21 | 
22 |   template <class B, class F>
23 |   B fold(B && init, ops::Fn<F, B(B &&, Item &&)> f) {
24 |     B accum = forward(init);
25 | 
26 |     Item x;
27 |     while ((let<Some<Item>>(x) = self().next())) {
28 |       accum = f(move(accum), move(x));
29 |     }
30 | 
31 |     return accum;
32 |   }
33 | };
34 | } // namespace iter
35 | } // namespace crust
36 | 
37 | 
38 | #endif // CRUST_ITER_MOD_HPP
39 | 


--------------------------------------------------------------------------------
/.github/workflows/test-msvc.yml:
--------------------------------------------------------------------------------
 1 | name: test-msvc
 2 | 
 3 | on: push
 4 | 
 5 | jobs:
 6 |   test:
 7 |     runs-on: windows-2019
 8 | 
 9 |     strategy:
10 |       fail-fast: false
11 |       matrix:
12 |         build: [Debug, Release]
13 |         standard: [cxx11, cxx14, cxx17, cxx20]
14 | 
15 |     defaults:
16 |       run:
17 |         shell: cmd
18 | 
19 |     name: "${{matrix.standard}}-${{matrix.build}}"
20 |     steps:
21 |     - uses: actions/checkout@v2
22 | 
23 |     - name: configure cmake
24 |       run: cmake -S %GITHUB_WORKSPACE% -B ${{runner.workspace}}\build -DCMAKE_BUILD_TYPE=${{matrix.build}}
25 | 
26 |     - name: build
27 |       working-directory: ${{runner.workspace}}\build
28 |       run: cmake --build . --config ${{matrix.build}} --target test-${{matrix.standard}}
29 | 
30 |     - name: test
31 |       working-directory: ${{runner.workspace}}\build
32 |       run: .\${{matrix.build}}\test-${{matrix.standard}}.exe -V
33 | 


--------------------------------------------------------------------------------
/test/option.cpp:
--------------------------------------------------------------------------------
 1 | #include "gtest/gtest.h"
 2 | 
 3 | #include "crust/cmp.hpp"
 4 | #include "crust/option.hpp"
 5 | #include "crust/utility.hpp"
 6 | 
 7 | 
 8 | using namespace crust;
 9 | using ops::bind;
10 | 
11 | 
12 | GTEST_TEST(option, option) {
13 |   EXPECT_TRUE(make_some(0) == make_some(0));
14 |   EXPECT_FALSE(make_some(0) == make_some(1));
15 |   EXPECT_TRUE(make_some(0) != make_some(1));
16 |   EXPECT_FALSE(make_some(0) != make_some(0));
17 |   EXPECT_TRUE(make_some(0) != None{});
18 |   EXPECT_FALSE(make_some(0) == None{});
19 | 
20 |   EXPECT_TRUE(make_some(0).is_some());
21 |   EXPECT_FALSE(make_some(0).is_none());
22 |   EXPECT_TRUE(make_none<i32>().is_none());
23 |   EXPECT_FALSE(make_none<i32>().is_some());
24 | 
25 |   EXPECT_TRUE(*make_some(1234).as_ptr().unwrap_or(0) == 1234);
26 |   EXPECT_TRUE(
27 |       *make_some(1234)
28 |            .map(bind([](const i32 &value) { return &value; }))
29 |            .unwrap_or(0) == 1234);
30 | }
31 | 


--------------------------------------------------------------------------------
/.clang-tidy:
--------------------------------------------------------------------------------
 1 | Checks: '-*,clang-diagnostic-*,llvm-*,misc-*,-llvm-header-guard,-llvm-else-after-return,-misc-non-private-member-variables-in-classes,-misc-unconventional-assign-operator'
 2 | 
 3 | CheckOptions:
 4 |   - key:             readability-identifier-naming.ClassCase
 5 |     value:           CamelCase
 6 |   - key:             readability-identifier-naming.EnumCase
 7 |     value:           CamelCase
 8 |   - key:             readability-identifier-naming.FunctionCase
 9 |     value:           lower_case
10 |   - key:             readability-identifier-naming.MemberCase
11 |     value:           lower_case
12 |   - key:             readability-identifier-naming.ParameterCase
13 |     value:           lower_case
14 |   - key:             readability-identifier-naming.UnionCase
15 |     value:           lower_case
16 |   - key:             readability-identifier-naming.VariableCase
17 |     value:           lower_case
18 |   - key:             readability-identifier-naming.StaticConstantCase
19 |     value:           UPPER_CASE
20 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2021 Cytosine2020
 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 | 


--------------------------------------------------------------------------------
/include/crust/slice.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef CRUST_SLICE_HPP
 2 | #define CRUST_SLICE_HPP
 3 | 
 4 | 
 5 | #include "crust/ops/mod.hpp"
 6 | #include "crust/utility.hpp"
 7 | 
 8 | 
 9 | namespace crust {
10 | template <class T>
11 | struct crust_ebco Slice : Impl<Slice<T>, Trait<index::Index, usize, T>> {
12 | private:
13 |   T *inner;
14 |   usize size;
15 | 
16 |   Slice() : inner{nullptr}, size{0} {}
17 | 
18 |   Slice(T *inner, usize size) : inner{inner}, size{size} {}
19 | 
20 | public:
21 |   static Slice from_ptr(T *inner) { return Slice{inner, 1}; }
22 | 
23 |   static Slice from_raw_parts(T *inner, usize size) {
24 |     return Slice{inner, size};
25 |   }
26 | 
27 |   usize len() const { return size; }
28 | 
29 |   bool is_empty() const { return len() == 0; }
30 | 
31 |   const T *as_ptr() const { return inner; }
32 | 
33 |   T *as_ptr() { return inner; }
34 | };
35 | 
36 | template <class T>
37 | CRUST_IMPL_FOR(CRUST_MACRO(index::Index<Slice<T>, usize, T>)) {
38 |   CRUST_IMPL_USE_SELF(Slice<T>);
39 | 
40 |   const T &index(usize index) const {
41 |     if (index >= self().len()) {
42 |       crust_panic("index out of boundary!");
43 |     }
44 |     return self().as_ptr()[index];
45 |   }
46 | 
47 |   T &index_mut(usize index) {
48 |     if (index >= self().len()) {
49 |       crust_panic("index_mut out of boundary!");
50 |     }
51 |     return self().as_ptr()[index];
52 |   }
53 | };
54 | } // namespace crust
55 | 
56 | 
57 | #endif // CRUST_SLICE_HPP
58 | 


--------------------------------------------------------------------------------
/include/crust/option.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef CRUST_OPTION_HPP
 2 | #define CRUST_OPTION_HPP
 3 | 
 4 | 
 5 | #include "crust/option_decl.hpp"
 6 | 
 7 | 
 8 | namespace crust {
 9 | namespace option {
10 | struct crust_ebco None :
11 |     TupleStruct<>,
12 |     Derive<
13 |         None,
14 |         Trait<ZeroSizedType>,
15 |         Trait<clone::Clone>,
16 |         Trait<cmp::PartialEq>,
17 |         Trait<cmp::Eq>,
18 |         Trait<cmp::PartialOrd>,
19 |         Trait<cmp::Ord>> {
20 |   CRUST_USE_BASE_CONSTRUCTORS(None, TupleStruct<>);
21 | };
22 | 
23 | template <class T>
24 | struct crust_ebco Some :
25 |     TupleStruct<T>,
26 |     Derive<
27 |         Some<T>,
28 |         Trait<ZeroSizedType>,
29 |         Trait<clone::Clone>,
30 |         Trait<cmp::PartialEq>,
31 |         Trait<cmp::Eq>,
32 |         Trait<cmp::PartialOrd>,
33 |         Trait<cmp::Ord>> {
34 |   CRUST_USE_BASE_CONSTRUCTORS(Some, TupleStruct<T>);
35 | };
36 | 
37 | template <class T>
38 | crust_always_inline constexpr Option<typename RemoveConstOrRefType<T>::Result>
39 | make_some(T &&value) {
40 |   return Some<typename RemoveConstOrRefType<T>::Result>{forward<T>(value)};
41 | }
42 | 
43 | template <class T>
44 | crust_always_inline constexpr Option<typename RemoveConstOrRefType<T>::Result>
45 | make_none() {
46 |   return None{};
47 | }
48 | 
49 | template <class T>
50 | template <class U, class F>
51 | constexpr Option<U> Option<T>::map(ops::Fn<F, U(const T &)> f) const {
52 |   return this->template visit<Option<U>>(
53 |       [&](const Some<T> &value) {
54 |         return make_some(f(value.template get<0>()));
55 |       },
56 |       [](const None &) { return make_none<U>(); });
57 | }
58 | 
59 | template <class T>
60 | crust_cxx14_constexpr Option<T> Option<T>::take() {
61 |   auto tmp = this->template move_variant<Option<T>>();
62 |   *this = None{};
63 |   return tmp;
64 | }
65 | } // namespace option
66 | 
67 | using option::make_none;
68 | using option::make_some;
69 | } // namespace crust
70 | 
71 | 
72 | #endif // CRUST_OPTION_HPP
73 | 


--------------------------------------------------------------------------------
/test/raii_checker.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef CRUST_TEST_RAII_CHECKER_HPP
 2 | #define CRUST_TEST_RAII_CHECKER_HPP
 3 | 
 4 | 
 5 | #include <memory>
 6 | #include <unordered_map>
 7 | 
 8 | #include "crust/utility.hpp"
 9 | 
10 | 
11 | namespace test {
12 | struct RAIITypeInfo {};
13 | 
14 | struct RAIIRecorder {
15 | private:
16 |   struct Record {
17 |     const RAIITypeInfo *type_info;
18 |   };
19 | 
20 |   std::unordered_map<void *, Record> record;
21 | 
22 | public:
23 |   RAIIRecorder() : record{} {}
24 | 
25 |   void construct(const RAIITypeInfo *type_info, void *self) {
26 |     crust_assert(record.find(self) == record.end());
27 |     record.emplace(self, Record{type_info});
28 |   }
29 | 
30 |   void deconstruct(const RAIITypeInfo *type_info, void *self) {
31 |     auto ptr = record.find(self);
32 |     crust_assert(ptr != record.end() && ptr->second.type_info == type_info);
33 |     record.erase(ptr);
34 |   }
35 | 
36 |   ~RAIIRecorder() { crust_assert(record.empty()); }
37 | };
38 | 
39 | template <class Self>
40 | struct RAIIChecker {
41 | private:
42 |   static const RAIITypeInfo TYPE_INFO;
43 | 
44 |   std::shared_ptr<RAIIRecorder> recorder;
45 | 
46 | public:
47 |   explicit RAIIChecker(std::shared_ptr<RAIIRecorder> recorder) :
48 |       recorder{std::move(recorder)} {
49 |     this->recorder->construct(&TYPE_INFO, this);
50 |   }
51 | 
52 |   RAIIChecker(const RAIIChecker &other) : recorder{other.recorder} {
53 |     this->recorder->construct(&TYPE_INFO, this);
54 |   }
55 | 
56 |   RAIIChecker(RAIIChecker &&other) noexcept : recorder{other.recorder} {
57 |     this->recorder->construct(&TYPE_INFO, this);
58 |   }
59 | 
60 |   RAIIChecker &operator=(const RAIIChecker &other) {
61 |     crust_assert(recorder == other.recorder);
62 |     return *this;
63 |   }
64 | 
65 |   RAIIChecker &operator=(RAIIChecker &&other) noexcept {
66 |     crust_assert(recorder == other.recorder);
67 |     return *this;
68 |   }
69 | 
70 |   ~RAIIChecker() { recorder->deconstruct(&TYPE_INFO, this); }
71 | };
72 | 
73 | template <class Self>
74 | const RAIITypeInfo RAIIChecker<Self>::TYPE_INFO{};
75 | } // namespace test
76 | 
77 | 
78 | #endif // CRUST_TEST_RAII_CHECKER_HPP
79 | 


--------------------------------------------------------------------------------
/include/crust/result.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef CRUST_RESULT_HPP
 2 | #define CRUST_RESULT_HPP
 3 | 
 4 | 
 5 | #include "crust/enum.hpp"
 6 | #include "crust/option.hpp"
 7 | #include "crust/utility.hpp"
 8 | 
 9 | 
10 | namespace crust {
11 | namespace result {
12 | template <class T>
13 | struct Ok;
14 | 
15 | template <class E>
16 | struct Err;
17 | 
18 | template <class T, class E>
19 | struct Result;
20 | } // namespace result
21 | 
22 | using result::Err;
23 | using result::Ok;
24 | using result::Result;
25 | 
26 | template <class T>
27 | struct BluePrint<Ok<T>> : TmplType<TupleStruct<T>> {};
28 | 
29 | template <class E>
30 | struct BluePrint<Err<E>> : TmplType<TupleStruct<E>> {};
31 | 
32 | template <class T, class E>
33 | struct BluePrint<Result<T, E>> : TmplType<Enum<Ok<T>, Err<E>>> {};
34 | 
35 | namespace result {
36 | template <class T>
37 | CRUST_ENUM_TUPLE_VARIANT(Ok, Ok<T>, T);
38 | 
39 | template <class E>
40 | CRUST_ENUM_TUPLE_VARIANT(Err, Err<E>, E);
41 | 
42 | template <class T, class E>
43 | struct crust_ebco Result :
44 |     Enum<Ok<T>, Err<E>>,
45 |     Derive<
46 |         Result<T, E>,
47 |         Trait<cmp::PartialEq>,
48 |         Trait<cmp::Eq>,
49 |         Trait<cmp::PartialOrd>,
50 |         Trait<cmp::Ord>> {
51 |   CRUST_ENUM_USE_BASE(Result, Enum<Ok<T>, Err<E>>);
52 | 
53 |   constexpr bool is_ok() const { return this->template is_variant<Ok<T>>(); }
54 | 
55 |   constexpr bool is_err() const { return this->template is_variant<Err<E>>(); }
56 | 
57 |   constexpr bool contains(const T &other) const {
58 |     return this->template visit<bool>(
59 |         [&](const Ok<T> &value) { return value.template get<0>() == other; },
60 |         [](const Err<E> &) { return false; });
61 |   }
62 | 
63 |   constexpr bool contains_err(const E &other) const {
64 |     return this->template visit<bool>(
65 |         [](const Ok<T> &) { return false; },
66 |         [&](const Err<E> &value) { return value.template get<0>() == other; });
67 |   }
68 | 
69 |   crust_cxx14_constexpr Option<T> ok() {
70 |     return this->template move_variant<Option<T>>();
71 |   }
72 | 
73 |   crust_cxx14_constexpr Option<E> err() {
74 |     return this->template move_variant<Option<E>>();
75 |   }
76 | };
77 | } // namespace result
78 | } // namespace crust
79 | 
80 | 
81 | #endif // CRUST_RESULT_HPP
82 | 


--------------------------------------------------------------------------------
/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required(VERSION 3.1)
 2 | 
 3 | project(crust)
 4 | 
 5 | add_compile_definitions(GTEST_DONT_DEFINE_TEST)
 6 | 
 7 | # Download and unpack googletest at configure time
 8 | configure_file(CMakeLists.txt.in googletest-download/CMakeLists.txt)
 9 | execute_process(COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" .
10 |     RESULT_VARIABLE result
11 |     WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/googletest-download)
12 | if (result)
13 |   message(FATAL_ERROR "CMake step for googletest failed: ${result}")
14 | endif ()
15 | execute_process(COMMAND ${CMAKE_COMMAND} --build .
16 |     RESULT_VARIABLE result
17 |     WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/googletest-download)
18 | if (result)
19 |   message(FATAL_ERROR "Build step for googletest failed: ${result}")
20 | endif ()
21 | 
22 | # Prevent overriding the parent project's compiler/linker
23 | # settings on Windows
24 | set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
25 | 
26 | # Add googletest directly to our build. This defines
27 | # the gtest and gtest_main targets.
28 | add_subdirectory(${CMAKE_CURRENT_BINARY_DIR}/googletest-src
29 |     ${CMAKE_CURRENT_BINARY_DIR}/googletest-build
30 |     EXCLUDE_FROM_ALL)
31 | 
32 | if (NOT MSVC)
33 |   add_compile_options(-Wall -Wextra -fno-exceptions -fno-rtti)
34 |   set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} \
35 |     -ggdb -g3 -fno-omit-frame-pointer -fprofile-arcs -ftest-coverage")
36 | else ()
37 |   add_compile_options(/W 3 /sdl /EHr /GR-)
38 |   set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /Z7")
39 | endif ()
40 | 
41 | IF(CMAKE_BUILD_TYPE MATCHES RELEASE)
42 | set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
43 | ENDIF(CMAKE_BUILD_TYPE MATCHES RELEASE)
44 | 
45 | include_directories(include)
46 | 
47 | file(GLOB TEST_SRC "test/*.hpp" "test/*.cpp")
48 | 
49 | add_executable(test-cxx11 ${TEST_SRC})
50 | target_compile_features(test-cxx11 PUBLIC cxx_std_11)
51 | target_link_libraries(test-cxx11 gtest_main)
52 | 
53 | add_executable(test-cxx14 ${TEST_SRC})
54 | target_compile_features(test-cxx14 PUBLIC cxx_std_14)
55 | target_link_libraries(test-cxx14 gtest_main)
56 | 
57 | add_executable(test-cxx17 ${TEST_SRC})
58 | target_compile_features(test-cxx17 PUBLIC cxx_std_17)
59 | target_link_libraries(test-cxx17 gtest_main)
60 | 
61 | add_executable(test-cxx20 ${TEST_SRC})
62 | target_compile_features(test-cxx20 PUBLIC cxx_std_20)
63 | target_link_libraries(test-cxx20 gtest_main)
64 | 


--------------------------------------------------------------------------------
/test/function.cpp:
--------------------------------------------------------------------------------
 1 | #include "gtest/gtest.h"
 2 | 
 3 | #include "crust/ops/function.hpp"
 4 | #include "crust/utility.hpp"
 5 | 
 6 | #include "raii_checker.hpp"
 7 | 
 8 | 
 9 | using namespace crust;
10 | using ops::bind;
11 | using ops::bind_mut;
12 | 
13 | 
14 | namespace {
15 | struct A : test::RAIIChecker<A> {
16 |   CRUST_USE_BASE_CONSTRUCTORS(A, test::RAIIChecker<A>);
17 | 
18 |   i32 operator()() { return 1; }
19 | 
20 |   i32 operator()() const { return 2; }
21 | 
22 |   i32 fn_a() { return 3; }
23 | 
24 |   i32 fn_b() const { return 4; }
25 | };
26 | 
27 | i32 fn_c() { return 5; }
28 | 
29 | i32 fn_d(i32 a) { return a; }
30 | 
31 | i32 fn_e(const i32 &a) { return a; }
32 | 
33 | i32 fn_f(i32 &a) { return a; }
34 | 
35 | i32 fn_g(i32 &&a) { return a; }
36 | 
37 | template <class F>
38 | i32 test_fn(ops::Fn<F, i32()> fn) {
39 |   return fn();
40 | }
41 | 
42 | template <class F>
43 | i32 test_fn_mut(ops::FnMut<F, i32()> fn) {
44 |   return fn();
45 | }
46 | 
47 | i32 test_dyn_fn(ops::DynFn<i32()> fn) { return fn(); }
48 | 
49 | i32 test_dyn_fn_mut(ops::DynFnMut<i32()> fn) { return fn(); }
50 | } // namespace
51 | 
52 | GTEST_TEST(function, raii) {
53 |   auto recorder = std::make_shared<test::RAIIRecorder>();
54 | 
55 |   GTEST_ASSERT_EQ(bind(crust_tmpl_val(&fn_d))(11), 11);
56 |   GTEST_ASSERT_EQ(bind(crust_tmpl_val(&fn_e))(12), 12);
57 |   GTEST_ASSERT_EQ(bind(crust_tmpl_val(&fn_g))(13), 13);
58 | 
59 |   i32 i = 14;
60 |   GTEST_ASSERT_EQ(bind(crust_tmpl_val(&fn_d))(i), 14);
61 |   GTEST_ASSERT_EQ(bind(crust_tmpl_val(&fn_e))(i), 14);
62 |   GTEST_ASSERT_EQ(bind(crust_tmpl_val(&fn_f))(i), 14);
63 | 
64 |   A a{recorder};
65 |   GTEST_ASSERT_EQ(bind(crust_tmpl_val(&A::fn_b))(a), 4);
66 |   GTEST_ASSERT_EQ(bind_mut(crust_tmpl_val(&A::fn_a))(a), 3);
67 | 
68 |   GTEST_ASSERT_EQ(test_fn(bind(crust_tmpl_val(&fn_c))), 5);
69 |   GTEST_ASSERT_EQ(test_fn(bind<i32()>(A{recorder})), 2);
70 |   GTEST_ASSERT_EQ(test_fn(bind([]() { return 7; })), 7);
71 | 
72 |   GTEST_ASSERT_EQ(test_fn_mut(bind_mut(crust_tmpl_val(&fn_c))), 5);
73 |   GTEST_ASSERT_EQ(test_fn_mut(bind_mut<i32()>(A{recorder})), 1);
74 |   GTEST_ASSERT_EQ(test_fn_mut(bind_mut([]() mutable { return 6; })), 6);
75 | 
76 |   GTEST_ASSERT_EQ(test_dyn_fn(crust_tmpl_val(&fn_c)), 5);
77 |   GTEST_ASSERT_EQ(test_dyn_fn(A{recorder}), 2);
78 |   GTEST_ASSERT_EQ(test_dyn_fn([]() { return 9; }), 9);
79 | 
80 |   GTEST_ASSERT_EQ(test_dyn_fn_mut(crust_tmpl_val(&fn_c)), 5);
81 |   GTEST_ASSERT_EQ(test_dyn_fn_mut(A{recorder}), 1);
82 |   GTEST_ASSERT_EQ(test_dyn_fn_mut([]() mutable { return 8; }), 8);
83 | }
84 | 


--------------------------------------------------------------------------------
/include/crust/helper/repeat_macro.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef CRUST_HELPER_REPEAT_MACRO_HPP
 2 | #define CRUST_HELPER_REPEAT_MACRO_HPP
 3 | 
 4 | 
 5 | #define CRUST_MACRO_REPEAT_1(FN) FN(0)
 6 | #define CRUST_MACRO_REPEAT_2(FN)                                               \
 7 |   CRUST_MACRO_REPEAT_1(FN)                                                     \
 8 |   FN(1)
 9 | #define CRUST_MACRO_REPEAT_3(FN)                                               \
10 |   CRUST_MACRO_REPEAT_2(FN)                                                     \
11 |   FN(2)
12 | #define CRUST_MACRO_REPEAT_4(FN)                                               \
13 |   CRUST_MACRO_REPEAT_3(FN)                                                     \
14 |   FN(3)
15 | #define CRUST_MACRO_REPEAT_5(FN)                                               \
16 |   CRUST_MACRO_REPEAT_4(FN)                                                     \
17 |   FN(4)
18 | #define CRUST_MACRO_REPEAT_6(FN)                                               \
19 |   CRUST_MACRO_REPEAT_5(FN)                                                     \
20 |   FN(5)
21 | #define CRUST_MACRO_REPEAT_7(FN)                                               \
22 |   CRUST_MACRO_REPEAT_6(FN)                                                     \
23 |   FN(6)
24 | #define CRUST_MACRO_REPEAT_8(FN)                                               \
25 |   CRUST_MACRO_REPEAT_7(FN)                                                     \
26 |   FN(7)
27 | #define CRUST_MACRO_REPEAT_9(FN)                                               \
28 |   CRUST_MACRO_REPEAT_8(FN)                                                     \
29 |   FN(8)
30 | #define CRUST_MACRO_REPEAT_10(FN)                                              \
31 |   CRUST_MACRO_REPEAT_9(FN)                                                     \
32 |   FN(9)
33 | #define CRUST_MACRO_REPEAT_11(FN)                                              \
34 |   CRUST_MACRO_REPEAT_10(FN)                                                    \
35 |   FN(10)
36 | #define CRUST_MACRO_REPEAT_12(FN)                                              \
37 |   CRUST_MACRO_REPEAT_11(FN)                                                    \
38 |   FN(11)
39 | #define CRUST_MACRO_REPEAT_13(FN)                                              \
40 |   CRUST_MACRO_REPEAT_12(FN)                                                    \
41 |   FN(12)
42 | #define CRUST_MACRO_REPEAT_14(FN)                                              \
43 |   CRUST_MACRO_REPEAT_13(FN)                                                    \
44 |   FN(13)
45 | #define CRUST_MACRO_REPEAT_15(FN)                                              \
46 |   CRUST_MACRO_REPEAT_14(FN)                                                    \
47 |   FN(14)
48 | #define CRUST_MACRO_REPEAT_16(FN)                                              \
49 |   CRUST_MACRO_REPEAT_15(FN)                                                    \
50 |   FN(15)
51 | #define CRUST_MACRO_REPEAT(N, FN) CRUST_MACRO_REPEAT_##N(FN)
52 | 
53 | 
54 | #endif // CRUST_HELPER_REPEAT_MACRO_HPP
55 | 


--------------------------------------------------------------------------------
/include/crust/enum.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef CRUST_ENUM_HPP
 2 | #define CRUST_ENUM_HPP
 3 | 
 4 | 
 5 | #include "crust/enum_decl.hpp"
 6 | 
 7 | #include "crust/cmp.hpp"
 8 | #include "crust/option.hpp"
 9 | #include "crust/utility.hpp"
10 | 
11 | 
12 | namespace crust {
13 | namespace _impl_enum {
14 | template <class Index, class... Fields>
15 | template <class T>
16 | constexpr Option<cmp::Ordering>
17 | EnumTagUnion<Index, Fields...>::PartialCmp::operator()(const T &value) const {
18 |   return operator_partial_cmp(value, other->unsafe_get_variant<T>());
19 | }
20 | 
21 | template <class Index, class... Fields>
22 | template <class T>
23 | constexpr cmp::Ordering
24 | EnumTagUnion<Index, Fields...>::Cmp::operator()(const T &value) const {
25 |   return operator_cmp(value, other->unsafe_get_variant<T>());
26 | }
27 | 
28 | template <class Index, class... Fields>
29 | constexpr Option<cmp::Ordering>
30 | EnumTagUnion<Index, Fields...>::partial_cmp(const EnumTagUnion &other) const {
31 |   return make_some(operator_cmp(*this, other)); // FIXME:
32 | }
33 | 
34 | template <class Index, class... Fields>
35 | constexpr cmp::Ordering
36 | EnumTagUnion<Index, Fields...>::cmp(const EnumTagUnion &other) const {
37 |   return operator_cmp(index, other.index)
38 |       .then(visit<cmp::Ordering>(Cmp{&other}));
39 | }
40 | 
41 | template <class Index, class... Fields>
42 | constexpr Option<cmp::Ordering>
43 | EnumTagOnly<Index, Fields...>::partial_cmp(const EnumTagOnly &other) const {
44 |   return operator_partial_cmp(index, other.index);
45 | }
46 | 
47 | template <class Index, class... Fields>
48 | constexpr cmp::Ordering
49 | EnumTagOnly<Index, Fields...>::cmp(const EnumTagOnly &other) const {
50 |   return operator_cmp(index, other.index);
51 | }
52 | 
53 | template <class Inner, class... Fields>
54 | template <class T>
55 | crust_cxx14_constexpr Option<T> Enum<Inner, Fields...>::move_variant() && {
56 |   return is_variant<T>() ?
57 |       make_some(move(inner.template unsafe_get_variant<T>())) :
58 |       None{};
59 | }
60 | 
61 | template <class T>
62 | struct LetEnum {
63 | private:
64 |   T &ref;
65 | 
66 | public:
67 |   explicit constexpr LetEnum(T &ref) : ref{ref} {}
68 | 
69 |   template <class... Fields>
70 |   crust_cxx14_constexpr bool operator=(Enum<Fields...> &&other) {
71 |     return other.inner.template let_helper<T>(ref);
72 |   }
73 | };
74 | } // namespace _impl_enum
75 | 
76 | template <class T>
77 | crust_cxx14_constexpr _impl_enum::LetEnum<T> let(T &ref) {
78 |   return _impl_enum::LetEnum<T>{ref};
79 | }
80 | 
81 | template <class S>
82 | constexpr Option<cmp::Ordering> ImplFor<
83 |     cmp::PartialOrd<S>,
84 |     EnableIf<_impl_derive::ImplForEnum<S, cmp::PartialOrd>>>::
85 |     partial_cmp(const Self &other) const {
86 |   return operator_partial_cmp(self().inner, other.inner);
87 | }
88 | 
89 | template <class S>
90 | constexpr cmp::Ordering
91 | ImplFor<cmp::Ord<S>, EnableIf<_impl_derive::ImplForEnum<S, cmp::Ord>>>::cmp(
92 |     const Self &other) const {
93 |   return operator_cmp(self().inner, other.inner);
94 | }
95 | } // namespace crust
96 | 
97 | 
98 | #endif // CRUST_ENUM_HPP
99 | 


--------------------------------------------------------------------------------
/include/crust/option_decl.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef CRUST_OPTION_DECL_HPP
  2 | #define CRUST_OPTION_DECL_HPP
  3 | 
  4 | 
  5 | #include "crust/enum_decl.hpp"
  6 | #include "crust/ops/function.hpp"
  7 | #include "crust/utility.hpp"
  8 | 
  9 | 
 10 | namespace crust {
 11 | namespace option {
 12 | struct None;
 13 | 
 14 | template <class T>
 15 | struct Some;
 16 | 
 17 | template <class T>
 18 | struct Option;
 19 | } // namespace option
 20 | 
 21 | using option::None;
 22 | using option::Option;
 23 | using option::Some;
 24 | 
 25 | template <>
 26 | struct BluePrint<option::None> : TmplType<TupleStruct<>> {};
 27 | 
 28 | template <class T>
 29 | struct BluePrint<option::Some<T>> : TmplType<TupleStruct<T>> {};
 30 | 
 31 | template <class T>
 32 | struct BluePrint<Option<T>> : TmplType<Enum<None, Some<T>>> {};
 33 | 
 34 | namespace option {
 35 | template <class T>
 36 | struct crust_ebco Option :
 37 |     Enum<None, Some<T>>,
 38 |     Derive<
 39 |         Option<T>,
 40 |         Trait<cmp::PartialEq>,
 41 |         Trait<cmp::Eq>,
 42 |         Trait<cmp::PartialOrd>,
 43 |         Trait<cmp::Ord>> {
 44 |   CRUST_ENUM_USE_BASE(Option, Enum<None, Some<T>>)
 45 | 
 46 |   constexpr bool is_some() const {
 47 |     return this->template is_variant<Some<T>>();
 48 |   }
 49 | 
 50 |   constexpr bool is_none() const { return this->template is_variant<None>(); }
 51 | 
 52 |   constexpr bool contains(const T &other) const {
 53 |     return this->template eq_variant<Some<T>>(other);
 54 |   }
 55 | 
 56 |   constexpr Option<const T *> as_ptr() const {
 57 |     return map(ops::bind([](const T &value) { return &value; }));
 58 |   }
 59 | 
 60 |   crust_cxx14_constexpr Option<T *> as_mut_ptr() {
 61 |     return map(ops::bind([](T &value) { return &value; }));
 62 |   }
 63 | 
 64 |   crust_cxx14_constexpr T unwrap() && {
 65 |     return this->template visit<T>(
 66 |         [](Some<T> &value) { return move(value.template get<0>()); },
 67 |         [](None &) {
 68 |           crust_panic("called `Option::unwrap()` on a `None` value");
 69 |         });
 70 |   }
 71 | 
 72 |   crust_cxx14_constexpr T unwrap_or(T &&d) && {
 73 |     return this->template visit<T>(
 74 |         [](Some<T> &value) { return move(value.template get<0>()); },
 75 |         [&](None &) { return d; });
 76 |   }
 77 | 
 78 |   template <class U, class F>
 79 |   constexpr Option<U> map(ops::Fn<F, U(const T &)> f) const;
 80 | 
 81 |   template <class U, class F>
 82 |   constexpr U map_or(U &&d, ops::Fn<F, U(const T &)> f) const {
 83 |     return this->template visit<U>(
 84 |         [&](const Some<T> &value) { return f(value.template get<0>()); },
 85 |         [&](const None &) { return move<U>(d); });
 86 |   }
 87 | 
 88 |   template <class U, class D, class F>
 89 |   constexpr U map_or_else(ops::Fn<D, U()> d, ops::Fn<F, U(const T &)> f) const {
 90 |     return this->template visit<U>(
 91 |         [&](const Some<T> &value) { return f(value.template get<0>()); },
 92 |         [&](const None &) { return d(); });
 93 |   }
 94 | 
 95 |   crust_cxx14_constexpr Option<T> take();
 96 | };
 97 | } // namespace option
 98 | } // namespace crust
 99 | 
100 | 
101 | #endif // CRUST_OPTION_DECL_HPP
102 | 


--------------------------------------------------------------------------------
/include/crust/num/mod.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef CRUST_NUM_MOD_HPP
  2 | #define CRUST_NUM_MOD_HPP
  3 | 
  4 | 
  5 | #include "crust/utility.hpp"
  6 | 
  7 | 
  8 | namespace crust {
  9 | namespace num {
 10 | namespace _impl_num {
 11 | template <class Type, Type min, Type max>
 12 | struct Int {
 13 |   static constexpr Type BITS = static_cast<Type>(8 * sizeof(Type));
 14 |   static constexpr Type MIN = min;
 15 |   static constexpr Type MAX = max;
 16 | };
 17 | } // namespace _impl_num
 18 | 
 19 | template <class Type>
 20 | struct Int;
 21 | 
 22 | template <>
 23 | struct Int<u8> : _impl_num::Int<u8, 0, 0xFF> {};
 24 | 
 25 | template <>
 26 | struct Int<u16> : _impl_num::Int<u16, 0, 0xFFFF> {};
 27 | 
 28 | template <>
 29 | struct Int<u32> : _impl_num::Int<u32, 0, 0xFFFFFFFF> {};
 30 | 
 31 | template <>
 32 | struct Int<u64> : _impl_num::Int<u64, 0, 0xFFFFFFFFFFFFFFFFULL> {};
 33 | 
 34 | template <>
 35 | struct Int<i8> : _impl_num::Int<i8, -0x80, 0x7F> {};
 36 | 
 37 | template <>
 38 | struct Int<i16> : _impl_num::Int<i16, -0x8000, 0x7FFF> {};
 39 | 
 40 | template <>
 41 | struct Int<i32> : _impl_num::Int<i32, -0x80000000LL, 0x7FFFFFFF> {};
 42 | 
 43 | template <>
 44 | struct Int<i64> :
 45 |     _impl_num::Int<
 46 |         i64,
 47 |         static_cast<i64>(0x8000000000000000ULL),
 48 |         0x7FFFFFFFFFFFFFFFLL> {};
 49 | } // namespace num
 50 | 
 51 | template <class A, class B>
 52 | struct AddVal : TmplVal<typename A::Result, A::result + B::result> {
 53 |   crust_static_assert(IsSame<typename A::Result, typename B::Result>::result);
 54 |   crust_static_assert(
 55 |       A::result <= num::Int<typename A::Result>::MAX - B::result);
 56 | };
 57 | 
 58 | template <class T, class... Vs>
 59 | struct SumVal;
 60 | 
 61 | template <class T, class V, class... Vs>
 62 | struct SumVal<T, V, Vs...> : AddVal<V, SumVal<T, Vs...>> {};
 63 | 
 64 | template <class T>
 65 | struct SumVal<T> : TmplVal<T, 0> {};
 66 | 
 67 | template <class A, class B>
 68 | struct SubVal : TmplVal<typename A::Result, A::result - B::result> {
 69 |   crust_static_assert(IsSame<typename A::Result, typename B::Result>::result);
 70 |   crust_static_assert(
 71 |       A::result >= num::Int<typename A::Result>::MIN + B::result);
 72 | };
 73 | 
 74 | template <class T>
 75 | struct IncVal : AddVal<T, TmplVal<typename T::Result, 1>> {};
 76 | 
 77 | template <class T>
 78 | struct DecVal : SubVal<T, TmplVal<typename T::Result, 1>> {};
 79 | 
 80 | template <class A, class B>
 81 | struct EQVal : BoolVal<(A::result == B::result)> {
 82 |   crust_static_assert(IsSame<typename A::Result, typename B::Result>::result);
 83 | };
 84 | 
 85 | template <class A, class B>
 86 | struct NEVal : BoolVal<(A::result != B::result)> {
 87 |   crust_static_assert(IsSame<typename A::Result, typename B::Result>::result);
 88 | };
 89 | 
 90 | template <class A, class B>
 91 | struct LTVal : BoolVal<(A::result < B::result)> {
 92 |   crust_static_assert(IsSame<typename A::Result, typename B::Result>::result);
 93 | };
 94 | 
 95 | template <class A, class B>
 96 | struct LEVal : BoolVal<(A::result <= B::result)> {
 97 |   crust_static_assert(IsSame<typename A::Result, typename B::Result>::result);
 98 | };
 99 | 
100 | template <class A, class B>
101 | struct GTVal : BoolVal<(A::result > B::result)> {
102 |   crust_static_assert(IsSame<typename A::Result, typename B::Result>::result);
103 | };
104 | 
105 | template <class A, class B>
106 | struct GEVal : BoolVal<(A::result >= B::result)> {
107 |   crust_static_assert(IsSame<typename A::Result, typename B::Result>::result);
108 | };
109 | } // namespace crust
110 | 
111 | 
112 | #endif // CRUST_NUM_MOD_HPP
113 | 


--------------------------------------------------------------------------------
/.clang-format:
--------------------------------------------------------------------------------
  1 | ---
  2 | Language: Cpp
  3 | 
  4 | MaxEmptyLinesToKeep: 2
  5 | 
  6 | ColumnLimit: 80
  7 | IndentWidth: 2
  8 | AccessModifierOffset: -2
  9 | ConstructorInitializerIndentWidth: 4
 10 | ContinuationIndentWidth: 4
 11 | 
 12 | NamespaceIndentation: None
 13 | CompactNamespaces: false
 14 | 
 15 | AlignAfterOpenBracket: AlwaysBreak
 16 | AlignConsecutiveMacros: false
 17 | AlignConsecutiveAssignments: false
 18 | AlignConsecutiveDeclarations: false
 19 | AlignEscapedNewlines: Right
 20 | AlignOperands: false
 21 | AlignTrailingComments: true
 22 | 
 23 | AllowAllArgumentsOnNextLine: true
 24 | AllowAllConstructorInitializersOnNextLine: true
 25 | AllowAllParametersOfDeclarationOnNextLine: true
 26 | AllowShortBlocksOnASingleLine: true
 27 | AllowShortCaseLabelsOnASingleLine: false
 28 | AllowShortFunctionsOnASingleLine: All
 29 | AllowShortLambdasOnASingleLine: All
 30 | AllowShortIfStatementsOnASingleLine: Never
 31 | AllowShortLoopsOnASingleLine: false
 32 | AlwaysBreakAfterDefinitionReturnType: None
 33 | AlwaysBreakAfterReturnType: None
 34 | AlwaysBreakBeforeMultilineStrings: false
 35 | AlwaysBreakTemplateDeclarations: Yes
 36 | BinPackArguments: false
 37 | BinPackParameters: false
 38 | BraceWrapping:
 39 |   AfterCaseLabel: false
 40 |   AfterClass: false
 41 |   AfterControlStatement: false
 42 |   AfterEnum: false
 43 |   AfterFunction: false
 44 |   AfterNamespace: false
 45 |   AfterObjCDeclaration: false
 46 |   AfterStruct: false
 47 |   AfterUnion: false
 48 |   AfterExternBlock: false
 49 |   BeforeCatch: false
 50 |   BeforeElse: false
 51 |   IndentBraces: false
 52 |   SplitEmptyFunction: false
 53 |   SplitEmptyRecord: false
 54 |   SplitEmptyNamespace: false
 55 | BreakBeforeBinaryOperators: None
 56 | BreakBeforeBraces: Attach
 57 | BreakBeforeInheritanceComma: false
 58 | BreakInheritanceList: AfterColon
 59 | BreakBeforeTernaryOperators: false
 60 | BreakConstructorInitializersBeforeComma: false
 61 | BreakConstructorInitializers: AfterColon
 62 | BreakAfterJavaFieldAnnotations: false
 63 | BreakStringLiterals: true
 64 | 
 65 | CommentPragmas: '^ IWYU pragma:'
 66 | 
 67 | ConstructorInitializerAllOnOneLineOrOnePerLine: false
 68 | 
 69 | Cpp11BracedListStyle: true
 70 | DeriveLineEnding: true
 71 | DerivePointerAlignment: false
 72 | DisableFormat: false
 73 | ExperimentalAutoDetectBinPacking: false
 74 | FixNamespaceComments: true
 75 | ForEachMacros:
 76 |   - foreach
 77 |   - Q_FOREACH
 78 |   - BOOST_FOREACH
 79 | IncludeBlocks: Preserve
 80 | IncludeCategories:
 81 |   - Regex: '^"(llvm|llvm-c|clang|clang-c)/'
 82 |     Priority: 2
 83 |     SortPriority: 0
 84 |   - Regex: '^(<|"(gtest|gmock|isl|json)/)'
 85 |     Priority: 3
 86 |     SortPriority: 0
 87 |   - Regex: '.*'
 88 |     Priority: 1
 89 |     SortPriority: 0
 90 | IncludeIsMainRegex: '(Test)?$'
 91 | IncludeIsMainSourceRegex: ''
 92 | IndentCaseLabels: false
 93 | IndentGotoLabels: false
 94 | IndentPPDirectives: None
 95 | 
 96 | IndentWrappedFunctionNames: false
 97 | KeepEmptyLinesAtTheStartOfBlocks: true
 98 | MacroBlockBegin: ''
 99 | MacroBlockEnd: ''
100 | 
101 | PenaltyBreakAssignment: 2
102 | PenaltyBreakBeforeFirstCallParameter: 19
103 | PenaltyBreakComment: 300
104 | PenaltyBreakFirstLessLess: 120
105 | PenaltyBreakString: 1000
106 | PenaltyBreakTemplateDeclaration: 10
107 | PenaltyExcessCharacter: 1000000
108 | PenaltyReturnTypeOnItsOwnLine: 3
109 | PointerAlignment: Right
110 | ReflowComments: true
111 | SortIncludes: true
112 | SortUsingDeclarations: true
113 | SpaceAfterCStyleCast: false
114 | SpaceAfterLogicalNot: false
115 | SpaceAfterTemplateKeyword: true
116 | SpaceBeforeAssignmentOperators: true
117 | SpaceBeforeCpp11BracedList: false
118 | SpaceBeforeCtorInitializerColon: true
119 | SpaceBeforeInheritanceColon: true
120 | SpaceBeforeParens: ControlStatements
121 | SpaceBeforeRangeBasedForLoopColon: true
122 | SpaceInEmptyBlock: false
123 | SpaceInEmptyParentheses: false
124 | SpacesBeforeTrailingComments: 1
125 | SpacesInAngles: false
126 | SpacesInConditionalStatement: false
127 | SpacesInContainerLiterals: true
128 | SpacesInCStyleCastParentheses: false
129 | SpacesInParentheses: false
130 | SpacesInSquareBrackets: false
131 | SpaceBeforeSquareBrackets: false
132 | Standard: Latest
133 | StatementMacros:
134 |   - Q_UNUSED
135 |   - QT_REQUIRE_VERSION
136 | TabWidth: 8
137 | UseCRLF: false
138 | UseTab: Never
139 | ...
140 | 


--------------------------------------------------------------------------------
/test/cmp.cpp:
--------------------------------------------------------------------------------
  1 | #include "gtest/gtest.h"
  2 | 
  3 | #include "crust/cmp.hpp"
  4 | #include "crust/tuple.hpp"
  5 | #include "crust/utility.hpp"
  6 | 
  7 | 
  8 | using namespace crust;
  9 | using namespace cmp;
 10 | using ops::bind;
 11 | 
 12 | 
 13 | GTEST_TEST(cmp, derive) {
 14 |   crust_static_assert(Require<bool, PartialEq>::result);
 15 |   crust_static_assert(Require<char, PartialEq>::result);
 16 |   crust_static_assert(Require<u8, PartialEq>::result);
 17 |   crust_static_assert(Require<i8, PartialEq>::result);
 18 |   crust_static_assert(Require<u16, PartialEq>::result);
 19 |   crust_static_assert(Require<i16, PartialEq>::result);
 20 |   crust_static_assert(Require<u32, PartialEq>::result);
 21 |   crust_static_assert(Require<i32, PartialEq>::result);
 22 |   crust_static_assert(Require<u64, PartialEq>::result);
 23 |   crust_static_assert(Require<i64, PartialEq>::result);
 24 |   crust_static_assert(Require<usize, PartialEq>::result);
 25 |   crust_static_assert(Require<isize, PartialEq>::result);
 26 | 
 27 |   crust_static_assert(Require<bool, Eq>::result);
 28 |   crust_static_assert(Require<char, Eq>::result);
 29 |   crust_static_assert(Require<u8, Eq>::result);
 30 |   crust_static_assert(Require<i8, Eq>::result);
 31 |   crust_static_assert(Require<u16, Eq>::result);
 32 |   crust_static_assert(Require<i16, Eq>::result);
 33 |   crust_static_assert(Require<u32, Eq>::result);
 34 |   crust_static_assert(Require<i32, Eq>::result);
 35 |   crust_static_assert(Require<u64, Eq>::result);
 36 |   crust_static_assert(Require<i64, Eq>::result);
 37 |   crust_static_assert(Require<usize, Eq>::result);
 38 |   crust_static_assert(Require<isize, Eq>::result);
 39 | 
 40 |   crust_static_assert(Require<bool, PartialOrd>::result);
 41 |   crust_static_assert(Require<char, PartialOrd>::result);
 42 |   crust_static_assert(Require<u8, PartialOrd>::result);
 43 |   crust_static_assert(Require<i8, PartialOrd>::result);
 44 |   crust_static_assert(Require<u16, PartialOrd>::result);
 45 |   crust_static_assert(Require<i16, PartialOrd>::result);
 46 |   crust_static_assert(Require<u32, PartialOrd>::result);
 47 |   crust_static_assert(Require<i32, PartialOrd>::result);
 48 |   crust_static_assert(Require<u64, PartialOrd>::result);
 49 |   crust_static_assert(Require<i64, PartialOrd>::result);
 50 |   crust_static_assert(Require<usize, PartialOrd>::result);
 51 |   crust_static_assert(Require<isize, PartialOrd>::result);
 52 | 
 53 |   crust_static_assert(Require<bool, Ord>::result);
 54 |   crust_static_assert(Require<char, Ord>::result);
 55 |   crust_static_assert(Require<u8, Ord>::result);
 56 |   crust_static_assert(Require<i8, Ord>::result);
 57 |   crust_static_assert(Require<u16, Ord>::result);
 58 |   crust_static_assert(Require<i16, Ord>::result);
 59 |   crust_static_assert(Require<u32, Ord>::result);
 60 |   crust_static_assert(Require<i32, Ord>::result);
 61 |   crust_static_assert(Require<u64, Ord>::result);
 62 |   crust_static_assert(Require<i64, Ord>::result);
 63 |   crust_static_assert(Require<usize, Ord>::result);
 64 |   crust_static_assert(Require<isize, Ord>::result);
 65 | }
 66 | 
 67 | 
 68 | GTEST_TEST(cmp, ordering) {
 69 |   crust_static_assert(make_less() == make_less());
 70 |   crust_static_assert(make_less() == make_less());
 71 |   crust_static_assert(make_equal() == make_equal());
 72 |   crust_static_assert(make_greater() == make_greater());
 73 |   EXPECT_TRUE(make_less() < make_equal());
 74 |   EXPECT_TRUE(make_less() < make_greater());
 75 |   EXPECT_TRUE(make_equal() < make_greater());
 76 | 
 77 |   EXPECT_EQ(make_equal().then(make_less()), make_less());
 78 |   EXPECT_EQ(make_less().then(make_equal()), make_less());
 79 |   EXPECT_EQ(make_greater().then(make_equal()), make_greater());
 80 |   EXPECT_EQ(
 81 |       make_equal().then_with(bind([]() { return make_less(); })), make_less());
 82 |   EXPECT_EQ(
 83 |       make_less().then_with(bind([]() { return make_equal(); })), make_less());
 84 |   EXPECT_EQ(
 85 |       make_greater().then_with(bind([]() { return make_equal(); })),
 86 |       make_greater());
 87 | }
 88 | 
 89 | 
 90 | GTEST_TEST(cmp, min_max) {
 91 |   EXPECT_EQ(tuple(0, 'b'), min(tuple(0, 'b'), tuple(1, 'a')));
 92 |   EXPECT_EQ(tuple(1, 'a'), max(tuple(0, 'b'), tuple(1, 'a')));
 93 | 
 94 |   EXPECT_EQ(
 95 |       tuple(0, 'b'),
 96 |       min_by_key(
 97 |           tuple(0, 'b'), tuple(1, 'a'), bind([](const Tuple<i32, char> &value) {
 98 |             return value.get<0>();
 99 |           })));
100 | 
101 |   EXPECT_EQ(
102 |       tuple(1, 'a'),
103 |       min_by_key(
104 |           tuple(0, 'b'), tuple(1, 'a'), bind([](const Tuple<i32, char> &value) {
105 |             return value.get<1>();
106 |           })));
107 | 
108 |   EXPECT_EQ(
109 |       tuple(1, 'a'),
110 |       max_by_key(
111 |           tuple(0, 'b'), tuple(1, 'a'), bind([](const Tuple<i32, char> &value) {
112 |             return value.get<0>();
113 |           })));
114 | 
115 |   EXPECT_EQ(
116 |       tuple(0, 'b'),
117 |       max_by_key(
118 |           tuple(0, 'b'), tuple(1, 'a'), bind([](const Tuple<i32, char> &value) {
119 |             return value.get<1>();
120 |           })));
121 | }
122 | 
123 | GTEST_TEST(cmp, reverse) {
124 |   crust_static_assert(sizeof(cmp::Reverse<i32>) == sizeof(i32));
125 |   crust_static_assert(Require<cmp::Reverse<i32>, PartialEq>::result);
126 |   crust_static_assert(Require<cmp::Reverse<i32>, Eq>::result);
127 |   crust_static_assert(Require<cmp::Reverse<i32>, PartialOrd>::result);
128 |   crust_static_assert(Require<cmp::Reverse<i32>, Ord>::result);
129 | 
130 |   cmp::Reverse<i32> a{0};
131 |   cmp::Reverse<i32> b{1};
132 | 
133 |   EXPECT_TRUE(a > b);
134 | }
135 | 


--------------------------------------------------------------------------------
/test/enum.cpp:
--------------------------------------------------------------------------------
  1 | #include "gtest/gtest.h"
  2 | 
  3 | #include "crust/cmp.hpp"
  4 | #include "crust/enum.hpp"
  5 | #include "crust/utility.hpp"
  6 | 
  7 | #include "raii_checker.hpp"
  8 | 
  9 | 
 10 | using namespace crust;
 11 | 
 12 | template <class T>
 13 | struct VisitType {
 14 |   constexpr bool operator()(const T &) const { return true; }
 15 | 
 16 |   template <class U>
 17 |   constexpr bool operator()(const U &) const {
 18 |     return false;
 19 |   }
 20 | };
 21 | 
 22 | struct ClassA;
 23 | 
 24 | struct ClassB;
 25 | 
 26 | struct EnumA;
 27 | 
 28 | namespace crust {
 29 | template <>
 30 | CRUST_IMPL_FOR(clone::Clone<ClassA>){};
 31 | 
 32 | template <>
 33 | CRUST_IMPL_FOR(clone::Clone<ClassB>){};
 34 | 
 35 | template <>
 36 | struct BluePrint<EnumA> : TmplType<Enum<ClassA, ClassB>> {};
 37 | } // namespace crust
 38 | 
 39 | struct ClassA : test::RAIIChecker<ClassA>, Impl<ClassA, Trait<clone::Clone>> {
 40 |   CRUST_USE_BASE_CONSTRUCTORS(ClassA, test::RAIIChecker<ClassA>);
 41 | };
 42 | 
 43 | struct ClassB : test::RAIIChecker<ClassB>, Impl<ClassB, Trait<clone::Clone>> {
 44 |   CRUST_USE_BASE_CONSTRUCTORS(ClassB, test::RAIIChecker<ClassB>);
 45 | };
 46 | 
 47 | struct EnumA : Enum<ClassA, ClassB>, Derive<EnumA, Trait<clone::Clone>> {
 48 |   CRUST_ENUM_USE_BASE(EnumA, Enum<ClassA, ClassB>);
 49 | };
 50 | 
 51 | GTEST_TEST(enum_, enum_) {
 52 |   crust_static_assert(!Require<EnumA, cmp::PartialEq>::result);
 53 |   crust_static_assert(!Require<EnumA, cmp::Eq>::result);
 54 | 
 55 |   auto recorder = std::make_shared<test::RAIIRecorder>(test::RAIIRecorder{});
 56 | 
 57 |   EnumA a;
 58 |   a = EnumA{ClassA{recorder}};
 59 |   EXPECT_TRUE(a.visit<bool>(VisitType<ClassA>{}));
 60 |   a = EnumA{ClassB{recorder}};
 61 |   EXPECT_TRUE(a.visit<bool>(VisitType<ClassB>{}));
 62 |   a = ClassA{recorder};
 63 |   EXPECT_TRUE(a.visit<bool>(VisitType<ClassA>{}));
 64 |   a = ClassB{recorder};
 65 |   EXPECT_TRUE(a.visit<bool>(VisitType<ClassB>{}));
 66 | 
 67 |   EnumA b;
 68 |   b = a;
 69 |   EXPECT_TRUE(b.visit<bool>(VisitType<ClassB>{}));
 70 | 
 71 |   a = ClassA{recorder};
 72 |   b = a.clone();
 73 |   EXPECT_TRUE(b.visit<bool>(VisitType<ClassA>{}));
 74 | 
 75 |   a = ClassB{recorder};
 76 |   b.clone_from(a);
 77 |   EXPECT_TRUE(b.visit<bool>(VisitType<ClassB>{}));
 78 | 
 79 |   b = move(a);
 80 |   EXPECT_TRUE(b.visit<bool>(VisitType<ClassB>{}));
 81 | 
 82 |   EnumA c{b};
 83 |   EXPECT_TRUE(b.visit<bool>(VisitType<ClassB>{}));
 84 | 
 85 |   EnumA d{move(c)};
 86 |   EXPECT_TRUE(d.visit<bool>(VisitType<ClassB>{}));
 87 | }
 88 | 
 89 | class A;
 90 | class B;
 91 | class C;
 92 | class D;
 93 | class E;
 94 | class F;
 95 | struct EnumB;
 96 | struct EnumC;
 97 | struct EnumD;
 98 | struct EnumE;
 99 | 
100 | namespace crust {
101 | template <>
102 | struct BluePrint<A> : TmplType<TupleStruct<>> {};
103 | 
104 | template <>
105 | struct BluePrint<B> : TmplType<TupleStruct<>> {};
106 | 
107 | template <>
108 | struct BluePrint<C> : TmplType<TupleStruct<i32>> {};
109 | 
110 | template <>
111 | struct BluePrint<D> : TmplType<TupleStruct<i32>> {};
112 | 
113 | template <>
114 | struct BluePrint<E> : TmplType<TupleStruct<i32>> {};
115 | 
116 | template <>
117 | struct BluePrint<F> : TmplType<TupleStruct<i32>> {};
118 | 
119 | template <>
120 | struct BluePrint<EnumB> : TmplType<Enum<A, B>> {};
121 | 
122 | template <>
123 | struct BluePrint<EnumC> : TmplType<Enum<A, B, C, D, E, F>> {};
124 | 
125 | template <>
126 | struct BluePrint<EnumD> : TmplType<Enum<A, B>> {};
127 | 
128 | template <>
129 | struct BluePrint<EnumE> : TmplType<Enum<A, B, C, D, E, F>> {};
130 | } // namespace crust
131 | 
132 | CRUST_ENUM_VARIANT(A);
133 | CRUST_ENUM_VARIANT(B);
134 | CRUST_ENUM_TUPLE_VARIANT(C, C, i32);
135 | CRUST_ENUM_TUPLE_VARIANT(D, D, i32);
136 | CRUST_ENUM_TUPLE_VARIANT(E, E, i32);
137 | CRUST_ENUM_TUPLE_VARIANT(F, F, i32);
138 | 
139 | struct crust_ebco EnumB :
140 |     Enum<A, B>,
141 |     Derive<EnumB, Trait<cmp::PartialEq>, Trait<cmp::Eq>> {
142 |   CRUST_ENUM_USE_BASE(EnumB, Enum<A, B>);
143 | };
144 | 
145 | struct crust_ebco EnumC :
146 |     Enum<A, B, C, D, E, F>,
147 |     Derive<EnumC, Trait<cmp::PartialEq>, Trait<cmp::Eq>> {
148 |   CRUST_ENUM_USE_BASE(EnumC, Enum<A, B, C, D, E, F>);
149 | };
150 | 
151 | struct crust_ebco EnumD :
152 |     Enum<EnumRepr<i16>, A, B>,
153 |     Derive<EnumD, Trait<cmp::PartialEq>, Trait<cmp::Eq>> {
154 |   CRUST_ENUM_USE_BASE(EnumD, Enum<EnumRepr<u16>, A, B>);
155 | };
156 | 
157 | struct crust_ebco EnumE :
158 |     Enum<EnumRepr<isize>, A, B, C, D, E, F>,
159 |     Derive<EnumE, Trait<cmp::PartialEq>, Trait<cmp::Eq>> {
160 |   CRUST_ENUM_USE_BASE(EnumE, Enum<EnumRepr<isize>, A, B, C, D, E, F>);
161 | };
162 | 
163 | 
164 | GTEST_TEST(enum_, tag_only) {
165 |   crust_static_assert(sizeof(EnumB) == sizeof(i32));
166 |   crust_static_assert(sizeof(EnumC) == 2 * sizeof(i32));
167 |   crust_static_assert(sizeof(EnumD) == sizeof(i16));
168 |   crust_static_assert(sizeof(EnumE) == 2 * sizeof(isize));
169 | }
170 | 
171 | GTEST_TEST(enum_, raii) {
172 |   crust_static_assert(std::is_trivially_copyable<EnumC>::value);
173 |   crust_static_assert(std::is_standard_layout<EnumC>::value);
174 | 
175 |   EnumC a;
176 |   a = A{};
177 |   EXPECT_TRUE(a.visit<bool>(VisitType<A>{}));
178 |   a = B{};
179 |   EXPECT_TRUE(a.visit<bool>(VisitType<B>{}));
180 |   a = C{};
181 |   EXPECT_TRUE(a.visit<bool>(VisitType<C>{}));
182 |   a = D{};
183 |   EXPECT_TRUE(a.visit<bool>(VisitType<D>{}));
184 |   a = E{};
185 |   EXPECT_TRUE(a.visit<bool>(VisitType<E>{}));
186 |   a = F{};
187 |   EXPECT_TRUE(a.visit<bool>(VisitType<F>{}));
188 | }
189 | 
190 | struct EnumF;
191 | 
192 | namespace crust {
193 | template <>
194 | struct BluePrint<EnumF> : TmplType<Enum<i32, char>> {};
195 | } // namespace crust
196 | 
197 | 
198 | struct crust_ebco EnumF :
199 |     Enum<i32, char>,
200 |     Derive<EnumF, Trait<cmp::PartialEq>, Trait<cmp::Eq>> {
201 |   CRUST_ENUM_USE_BASE(EnumF, Enum<i32, char>);
202 | };
203 | 
204 | 
205 | GTEST_TEST(enum_, cmp) {
206 |   EXPECT_TRUE(EnumF{0} == EnumF{0});
207 |   EXPECT_TRUE(EnumF{0} != EnumF{'a'});
208 |   EXPECT_TRUE(EnumF{0} != EnumF{1});
209 | }
210 | 


--------------------------------------------------------------------------------
/include/crust/helper/types.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef CRUST_HELPER_TYPES_HPP
  2 | #define CRUST_HELPER_TYPES_HPP
  3 | 
  4 | 
  5 | #include "crust/num/mod.hpp"
  6 | #include "crust/utility.hpp"
  7 | 
  8 | 
  9 | namespace crust {
 10 | namespace _impl_types {
 11 | template <class... Fields>
 12 | struct Types : TmplVal<usize, sizeof...(Fields)> {};
 13 | 
 14 | template <class T, class Ts>
 15 | struct TypesPushFront;
 16 | 
 17 | template <class T, class... Fields>
 18 | struct TypesPushFront<T, Types<Fields...>> : TmplType<Types<T, Fields...>> {};
 19 | 
 20 | template <usize index, class Ts>
 21 | struct TypesIndex;
 22 | 
 23 | template <usize index, class Field, class... Fields>
 24 | struct TypesIndex<index, Types<Field, Fields...>> :
 25 |     TypesIndex<index - 1, Types<Fields...>> {};
 26 | 
 27 | template <class Field, class... Fields>
 28 | struct TypesIndex<0, Types<Field, Fields...>> : TmplType<Field> {};
 29 | 
 30 | template <usize index, class Ts>
 31 | struct TypesAfter;
 32 | 
 33 | template <usize index, class Field, class... Fields>
 34 | struct TypesAfter<index, Types<Field, Fields...>> :
 35 |     TypesAfter<index - 1, Types<Fields...>> {};
 36 | 
 37 | template <class Field, class... Fields>
 38 | struct TypesAfter<0, Types<Field, Fields...>> : TmplType<Types<Fields...>> {};
 39 | 
 40 | template <usize index, class Ts>
 41 | struct TypesBefore;
 42 | 
 43 | template <usize index, class Field, class... Fields>
 44 | struct TypesBefore<index, Types<Field, Fields...>> :
 45 |     TypesPushFront<
 46 |         Field,
 47 |         typename TypesBefore<index - 1, Types<Fields...>>::Result> {};
 48 | 
 49 | template <class Field, class... Fields>
 50 | struct TypesBefore<0, Types<Field, Fields...>> : TmplType<Types<>> {};
 51 | 
 52 | template <class T, class Ts>
 53 | struct TypesCountType;
 54 | 
 55 | template <class T, class... Fields>
 56 | struct TypesCountType<T, Types<Fields...>> :
 57 |     SumVal<usize, AsVal<usize, IsSame<T, Fields>>...> {};
 58 | 
 59 | template <class T, class Ts>
 60 | struct TypesIncludeVal : GTVal<TypesCountType<T, Ts>, TmplVal<usize, 0>> {};
 61 | 
 62 | template <class Ts>
 63 | struct TypesDuplicateVal;
 64 | 
 65 | template <class Field, class... Fields>
 66 | struct TypesDuplicateVal<Types<Field, Fields...>> :
 67 |     Any<TypesIncludeVal<Field, Types<Fields...>>,
 68 |         TypesDuplicateVal<Types<Fields...>>> {};
 69 | 
 70 | template <>
 71 | struct TypesDuplicateVal<Types<>> : BoolVal<false> {};
 72 | 
 73 | template <class T, class Ts>
 74 | struct TypesFirstIndex;
 75 | 
 76 | template <class T, class Field, class... Fields>
 77 | struct TypesFirstIndex<T, Types<Field, Fields...>> :
 78 |     IncVal<TypesFirstIndex<T, Types<Fields...>>> {};
 79 | 
 80 | template <class T, class... Fields>
 81 | struct TypesFirstIndex<T, Types<T, Fields...>> : TmplVal<usize, 0> {};
 82 | 
 83 | template <class T, class... Fields>
 84 | struct TypesPrevType :
 85 |     TypesIndex<
 86 |         DecVal<TypesFirstIndex<T, Types<Fields...>>>::result,
 87 |         Types<Fields...>> {};
 88 | 
 89 | template <class T, class Ts>
 90 | struct TypesContainVal;
 91 | 
 92 | template <class T, class... Fields>
 93 | struct TypesContainVal<T, Types<Fields...>> :
 94 |     Any<ZeroSizedTypeConvertible<Fields, T>...> {};
 95 | 
 96 | template <usize index, class Ts>
 97 | using ZeroSizedTypeHolderFieldEnable =
 98 |     All<Require<typename TypesIndex<index, Ts>::Result, ZeroSizedType>,
 99 |         Not<TypesIncludeVal<
100 |             typename TypesIndex<index, Ts>::Result,
101 |             typename TypesBefore<index, Ts>::Result>>,
102 |         Not<TypesContainVal<typename TypesIndex<index, Ts>::Result, Ts>>>;
103 | 
104 | template <class T, class Ts, usize index = 0>
105 | struct TypesFirstContain :
106 |     IfElse<
107 |         All<ZeroSizedTypeHolderFieldEnable<index, Ts>,
108 |             ZeroSizedTypeConvertible<
109 |                 typename TypesIndex<index, Ts>::Result,
110 |                 T>>,
111 |         TmplVal<usize, index>,
112 |         TypesFirstContain<T, Ts, index + 1>> {};
113 | 
114 | template <usize index, class Ts>
115 | using ZeroSizedTypeHolderField = InheritIf<
116 |     typename TypesIndex<index, Ts>::Result,
117 |     ZeroSizedTypeHolderFieldEnable<index, Ts>,
118 |     TypesIndex<index, Ts>>;
119 | 
120 | template <usize remain, class Ts>
121 | struct crust_ebco ZeroSizedTypeHolderImpl :
122 |     ZeroSizedTypeHolderField<Ts::result - remain, Ts>,
123 |     ZeroSizedTypeHolderImpl<remain - 1, Ts> {
124 |   constexpr ZeroSizedTypeHolderImpl() {}
125 | };
126 | 
127 | template <class Ts>
128 | struct ZeroSizedTypeHolderImpl<0, Ts> {};
129 | 
130 | template <class... Fields>
131 | using ZeroSizedTypeHolder =
132 |     ZeroSizedTypeHolderImpl<sizeof...(Fields), Types<Fields...>>;
133 | 
134 | template <bool direct, usize index, class... Fields>
135 | struct ZeroSizedTypeGetterImpl;
136 | 
137 | template <usize index, class... Fields>
138 | using ZeroSizedTypeGetter = ZeroSizedTypeGetterImpl<
139 |     TypesContainVal<
140 |         typename TypesIndex<index, Types<Fields...>>::Result,
141 |         Types<Fields...>>::result,
142 |     index,
143 |     Fields...>;
144 | 
145 | template <usize index, class... Fields>
146 | struct ZeroSizedTypeGetterImpl<false, index, Fields...> {
147 |   using Self = ZeroSizedTypeHolder<Fields...>;
148 |   using Result = typename TypesIndex<index, Types<Fields...>>::Result;
149 |   using Field = ZeroSizedTypeHolderField<
150 |       TypesFirstIndex<Result, Types<Fields...>>::result,
151 |       Types<Fields...>>;
152 | 
153 |   static constexpr const Result &inner(const Self &self) {
154 |     return static_cast<const Field &>(self);
155 |   }
156 | 
157 |   static constexpr Result &inner(Self &self) {
158 |     return static_cast<Field &>(self);
159 |   }
160 | };
161 | 
162 | template <usize index, class... Fields>
163 | struct ZeroSizedTypeGetterImpl<true, index, Fields...> {
164 |   using Self = ZeroSizedTypeHolder<Fields...>;
165 |   using Result = typename TypesIndex<index, Types<Fields...>>::Result;
166 |   static constexpr usize field_index =
167 |       TypesFirstContain<Result, Types<Fields...>>::result;
168 |   using Field = ZeroSizedTypeHolderField<field_index, Types<Fields...>>;
169 |   using Convert = ZeroSizedTypeConvert<
170 |       typename TypesIndex<field_index, Types<Fields...>>::Result,
171 |       Result>;
172 | 
173 |   static constexpr const Result &inner(const Self &self) {
174 |     return Convert::inner(static_cast<const Field &>(self));
175 |   }
176 | 
177 |   static constexpr Result &inner(Self &self) {
178 |     return Convert::inner(static_cast<Field &>(self));
179 |   }
180 | };
181 | } // namespace _impl_types
182 | } // namespace crust
183 | 
184 | 
185 | #endif // CRUST_HELPER_TYPES_HPP
186 | 


--------------------------------------------------------------------------------
/include/crust/cmp_decl.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef CRUST_CMP_DECL_HPP
  2 | #define CRUST_CMP_DECL_HPP
  3 | 
  4 | 
  5 | #include "crust/utility.hpp"
  6 | 
  7 | 
  8 | namespace crust {
  9 | namespace option {
 10 | template <class T>
 11 | struct Option;
 12 | } // namespace option
 13 | 
 14 | using option::Option;
 15 | 
 16 | namespace cmp {
 17 | struct Ordering;
 18 | 
 19 | CRUST_TRAIT(PartialEq, class Rhs = Self) {
 20 |   CRUST_TRAIT_USE_SELF(PartialEq);
 21 | 
 22 |   bool eq(const Rhs &other) const;
 23 | 
 24 |   constexpr bool ne(const Rhs &other) const { return !self().eq(other); }
 25 | 
 26 |   constexpr friend bool operator==(const Self &self_, const Rhs &other) {
 27 |     return static_cast<const ImplFor<PartialEq<Self>> &>(self_).eq(other);
 28 |   }
 29 | 
 30 |   constexpr friend bool operator!=(const Self &self_, const Rhs &other) {
 31 |     return static_cast<const ImplFor<PartialEq<Self>> &>(self_).ne(other);
 32 |   }
 33 | };
 34 | 
 35 | CRUST_TRAIT(Eq) { CRUST_TRAIT_USE_SELF(Eq, Require<Self, PartialEq>); };
 36 | 
 37 | CRUST_TRAIT(PartialOrd, class Rhs = Self) {
 38 |   CRUST_TRAIT_USE_SELF(PartialOrd, Require<Self, PartialEq>);
 39 | 
 40 |   Option<Ordering> partial_cmp(const Rhs &other) const;
 41 | 
 42 |   constexpr bool lt(const Rhs &other) const;
 43 | 
 44 |   constexpr bool le(const Rhs &other) const;
 45 | 
 46 |   constexpr bool gt(const Rhs &other) const;
 47 | 
 48 |   constexpr bool ge(const Rhs &other) const;
 49 | 
 50 |   constexpr friend bool operator<(const Self &self_, const Rhs &other) {
 51 |     return static_cast<const ImplFor<PartialOrd<Self>> &>(self_).lt(other);
 52 |   }
 53 | 
 54 |   constexpr friend bool operator<=(const Self &self_, const Rhs &other) {
 55 |     return static_cast<const ImplFor<PartialOrd<Self>> &>(self_).le(other);
 56 |   }
 57 | 
 58 |   constexpr friend bool operator>(const Self &self_, const Rhs &other) {
 59 |     return static_cast<const ImplFor<PartialOrd<Self>> &>(self_).gt(other);
 60 |   }
 61 | 
 62 |   constexpr friend bool operator>=(const Self &self_, const Rhs &other) {
 63 |     return static_cast<const ImplFor<PartialOrd<Self>> &>(self_).ge(other);
 64 |   }
 65 | };
 66 | 
 67 | CRUST_TRAIT(Ord) {
 68 |   CRUST_TRAIT_USE_SELF(
 69 |       Ord,
 70 |       Require<Self, PartialEq>,
 71 |       Require<Self, Eq>,
 72 |       Require<Self, PartialOrd>);
 73 | 
 74 |   Ordering cmp(const Self &other) const;
 75 | 
 76 |   crust_cxx14_constexpr Self max(Self && other) && {
 77 |     return self<PartialOrd<Self>>().gt(other) ?
 78 |         move(*static_cast<Self *>(this)) :
 79 |         move(other);
 80 |   }
 81 | 
 82 |   crust_cxx14_constexpr Self min(Self && other) && {
 83 |     return self<PartialOrd<Self>>().gt(other) ?
 84 |         move(other) :
 85 |         move(*static_cast<Self *>(this));
 86 |   }
 87 | 
 88 |   crust_cxx14_constexpr Self clamp(Self && min, Self && max) && {
 89 |     return crust_debug_assert(min <= max),
 90 |            self<PartialOrd<Self>>().lt(min) ?
 91 |                move(min) :
 92 |                (self<PartialOrd<Self>>().gt(max) ?
 93 |                     move(max) :
 94 |                     move(*static_cast<Self *>(this)));
 95 |   }
 96 | };
 97 | } // namespace cmp
 98 | 
 99 | namespace _impl_derive {
100 | template <class Self, class Base, usize rev_index = TupleLikeSize<Base>::result>
101 | struct TupleLikePartialEqHelper {
102 |   static constexpr usize index = TupleLikeSize<Base>::result - rev_index;
103 |   using Getter = TupleLikeGetter<Base, index>;
104 |   using Remains = TupleLikePartialEqHelper<Self, Base, rev_index - 1>;
105 | 
106 |   static constexpr bool eq(const Self &a, const Self &b) {
107 |     return Getter::get(a) == Getter::get(b) && Remains::eq(a, b);
108 |   }
109 | 
110 |   static constexpr bool ne(const Self &a, const Self &b) {
111 |     return Getter::get(a) != Getter::get(b) || Remains::ne(a, b);
112 |   }
113 | };
114 | 
115 | template <class Self, class Base>
116 | struct TupleLikePartialEqHelper<Self, Base, 0> {
117 |   static constexpr bool eq(const Self &, const Self &) { return true; }
118 | 
119 |   static constexpr bool ne(const Self &, const Self &) { return false; }
120 | };
121 | 
122 | template <class Self, class Base, usize rev_index = TupleLikeSize<Base>::result>
123 | struct TupleLikePartialOrdHelper {
124 |   static constexpr usize index = TupleLikeSize<Base>::result - rev_index;
125 |   using Getter = TupleLikeGetter<Base, index>;
126 |   using Remains = TupleLikePartialOrdHelper<Self, Base, rev_index - 1>;
127 | 
128 |   static constexpr Option<cmp::Ordering>
129 |   partial_cmp(const Self &a, const Self &b);
130 | 
131 |   static constexpr bool lt(const Self &a, const Self &b) {
132 |     return Getter::get(a) != Getter::get(b) ? Getter::get(a) < Getter::get(b) :
133 |                                               Remains::lt(a, b);
134 |   }
135 | 
136 |   static constexpr bool le(const Self &a, const Self &b) {
137 |     return Getter::get(a) != Getter::get(b) ? Getter::get(a) <= Getter::get(b) :
138 |                                               Remains::le(a, b);
139 |   }
140 | 
141 |   static constexpr bool gt(const Self &a, const Self &b) {
142 |     return Getter::get(a) != Getter::get(b) ? Getter::get(a) > Getter::get(b) :
143 |                                               Remains::gt(a, b);
144 |   }
145 | 
146 |   static constexpr bool ge(const Self &a, const Self &b) {
147 |     return Getter::get(a) != Getter::get(b) ? Getter::get(a) >= Getter::get(b) :
148 |                                               Remains::ge(a, b);
149 |   }
150 | };
151 | 
152 | template <class Self, class Base>
153 | struct TupleLikePartialOrdHelper<Self, Base, 0> {
154 |   static constexpr Option<cmp::Ordering>
155 |   partial_cmp(const Self &, const Self &);
156 | 
157 |   static constexpr bool lt(const Self &, const Self &) { return false; }
158 | 
159 |   static constexpr bool le(const Self &, const Self &) { return true; }
160 | 
161 |   static constexpr bool gt(const Self &, const Self &) { return false; }
162 | 
163 |   static constexpr bool ge(const Self &, const Self &) { return true; }
164 | };
165 | 
166 | template <class Self, class Base, usize rev_index = TupleLikeSize<Base>::result>
167 | struct TupleLikeOrdHelper {
168 |   static constexpr usize index = TupleLikeSize<Base>::result - rev_index;
169 |   using Getter = TupleLikeGetter<Base, index>;
170 |   using Remains = TupleLikeOrdHelper<Self, Base, rev_index - 1>;
171 | 
172 |   static constexpr cmp::Ordering cmp(const Self &a, const Self &b);
173 | };
174 | 
175 | template <class Self, class Base>
176 | struct TupleLikeOrdHelper<Self, Base, 0> {
177 |   static constexpr cmp::Ordering cmp(const Self &, const Self &);
178 | };
179 | } // namespace _impl_derive
180 | } // namespace crust
181 | 
182 | 
183 | #endif // CRUST_CMP_DECL_HPP
184 | 


--------------------------------------------------------------------------------
/test/tuple.cpp:
--------------------------------------------------------------------------------
  1 | #include "gtest/gtest.h"
  2 | 
  3 | #include "crust/clone.hpp"
  4 | #include "crust/cmp.hpp"
  5 | #include "crust/tuple.hpp"
  6 | #include "crust/utility.hpp"
  7 | 
  8 | #include "raii_checker.hpp"
  9 | 
 10 | 
 11 | #include <tuple>
 12 | 
 13 | using namespace crust;
 14 | using namespace cmp;
 15 | 
 16 | 
 17 | namespace {
 18 | struct C;
 19 | 
 20 | struct D;
 21 | } // namespace
 22 | 
 23 | namespace crust {
 24 | template <>
 25 | CRUST_IMPL_FOR(clone::Clone<C>){};
 26 | 
 27 | template <>
 28 | CRUST_IMPL_FOR(clone::Clone<D>){};
 29 | } // namespace crust
 30 | 
 31 | namespace {
 32 | struct A {};
 33 | 
 34 | struct B : A {};
 35 | 
 36 | struct C : test::RAIIChecker<C>, Impl<C, Trait<clone::Clone>> {
 37 |   CRUST_USE_BASE_CONSTRUCTORS(C, test::RAIIChecker<C>);
 38 | };
 39 | 
 40 | struct D : test::RAIIChecker<D>, Impl<D, Trait<clone::Clone>> {
 41 |   CRUST_USE_BASE_CONSTRUCTORS(D, test::RAIIChecker<D>);
 42 | };
 43 | } // namespace
 44 | 
 45 | 
 46 | GTEST_TEST(tuple, size_zero) {
 47 |   crust_static_assert(Require<Tuple<>, ZeroSizedType>::result);
 48 |   crust_static_assert(Require<Tuple<Tuple<>>, ZeroSizedType>::result);
 49 |   crust_static_assert(Require<Tuple<Tuple<>, Tuple<>>, ZeroSizedType>::result);
 50 |   crust_static_assert(
 51 |       Require<Tuple<Tuple<>, Tuple<>, Tuple<>>, ZeroSizedType>::result);
 52 | 
 53 |   crust_static_assert(sizeof(Tuple<>) == 1);
 54 |   crust_static_assert(sizeof(Tuple<Tuple<>>) == 1);
 55 |   crust_static_assert(sizeof(Tuple<Tuple<>, Tuple<>>) == 1);
 56 |   crust_static_assert(sizeof(Tuple<Tuple<>, Tuple<>, Tuple<>>) == 1);
 57 |   crust_static_assert(sizeof(Tuple<Tuple<>, Tuple<>, Tuple<Tuple<>>>) == 1);
 58 |   crust_static_assert(sizeof(Tuple<Tuple<>, Tuple<Tuple<>>, Tuple<>>) == 1);
 59 |   crust_static_assert(sizeof(Tuple<Tuple<Tuple<>>, Tuple<>, Tuple<>>) == 1);
 60 |   crust_static_assert(
 61 |       sizeof(Tuple<Tuple<>, Tuple<Tuple<>>, Tuple<Tuple<Tuple<>>>>) == 1);
 62 |   crust_static_assert(
 63 |       sizeof(Tuple<Tuple<>, Tuple<Tuple<Tuple<>>>, Tuple<Tuple<>>>) == 1);
 64 |   crust_static_assert(
 65 |       sizeof(Tuple<Tuple<Tuple<>>, Tuple<>, Tuple<Tuple<Tuple<>>>>) == 1);
 66 |   crust_static_assert(
 67 |       sizeof(Tuple<Tuple<Tuple<>>, Tuple<Tuple<Tuple<>>>, Tuple<>>) == 1);
 68 |   crust_static_assert(
 69 |       sizeof(Tuple<Tuple<Tuple<Tuple<>>>, Tuple<>, Tuple<Tuple<>>>) == 1);
 70 |   crust_static_assert(
 71 |       sizeof(Tuple<Tuple<Tuple<Tuple<>>>, Tuple<Tuple<>>, Tuple<>>) == 1);
 72 |   crust_static_assert(sizeof(Tuple<i32, Tuple<>, Tuple<>>) == sizeof(i32));
 73 |   crust_static_assert(sizeof(Tuple<Tuple<>, i32, Tuple<>>) == sizeof(i32));
 74 |   crust_static_assert(sizeof(Tuple<Tuple<>, Tuple<>, i32>) == sizeof(i32));
 75 |   crust_static_assert(
 76 |       sizeof(Tuple<i32, Tuple<i32>, Tuple<>>) == 2 * sizeof(i32));
 77 |   crust_static_assert(
 78 |       sizeof(Tuple<Tuple<i32>, i32, Tuple<>>) == 2 * sizeof(i32));
 79 |   crust_static_assert(
 80 |       sizeof(Tuple<Tuple<i32>, Tuple<>, i32>) == 2 * sizeof(i32));
 81 |   crust_static_assert(
 82 |       sizeof(Tuple<i32, Tuple<>, Tuple<i32>>) == 2 * sizeof(i32));
 83 |   crust_static_assert(
 84 |       sizeof(Tuple<Tuple<>, i32, Tuple<i32>>) == 2 * sizeof(i32));
 85 |   crust_static_assert(
 86 |       sizeof(Tuple<Tuple<>, Tuple<i32>, i32>) == 2 * sizeof(i32));
 87 | 
 88 |   constexpr auto empty_1 = tuple(tuple(), tuple(), tuple());
 89 |   crust_static_assert(empty_1.get<0>() == tuple());
 90 |   crust_static_assert(empty_1.get<1>() == tuple());
 91 |   crust_static_assert(empty_1.get<2>() == tuple());
 92 | 
 93 |   constexpr auto empty_2 = tuple(tuple(), 1);
 94 |   crust_static_assert(empty_2.get<0>() == tuple());
 95 |   crust_static_assert(empty_2.get<1>() == 1);
 96 | 
 97 |   constexpr auto empty_3 = tuple(tuple(), tuple(tuple()));
 98 |   crust_static_assert(empty_3.get<0>() == tuple());
 99 |   crust_static_assert(empty_3.get<1>() == tuple(tuple()));
100 |   crust_static_assert(empty_3.get<1>().get<0>() == tuple());
101 | 
102 |   constexpr auto empty_4 = tuple(tuple(tuple()), tuple());
103 |   crust_static_assert(empty_4.get<0>() == tuple(tuple()));
104 |   crust_static_assert(empty_4.get<1>() == tuple());
105 |   crust_static_assert(empty_4.get<0>().get<0>() == tuple());
106 | 
107 |   constexpr auto empty_5 =
108 |       tuple(tuple(tuple()), tuple(tuple(tuple())), tuple());
109 |   crust_static_assert(empty_5.get<0>() == tuple(tuple()));
110 |   crust_static_assert(empty_5.get<0>().get<0>() == tuple());
111 |   crust_static_assert(empty_5.get<1>() == tuple(tuple(tuple())));
112 |   crust_static_assert(empty_5.get<1>().get<0>() == tuple(tuple()));
113 |   crust_static_assert(empty_5.get<1>().get<0>().get<0>() == tuple());
114 |   crust_static_assert(empty_5.get<2>() == tuple());
115 | 
116 |   crust_static_assert(Require<Tuple<>, PartialEq>::result);
117 |   crust_static_assert(Require<Tuple<>, Eq>::result);
118 | 
119 |   crust_static_assert(std::is_trivially_copyable<Tuple<>>::value);
120 | 
121 |   crust_static_assert(tuple() == tuple());
122 |   crust_static_assert(!(tuple() != tuple()));
123 |   crust_static_assert(!(tuple() < tuple()));
124 |   crust_static_assert(tuple() <= tuple());
125 |   crust_static_assert(!(tuple() > tuple()));
126 |   crust_static_assert(tuple() >= tuple());
127 |   EXPECT_EQ(operator_partial_cmp(tuple(), tuple()), make_some(make_equal()));
128 |   EXPECT_EQ(operator_cmp(tuple(), tuple()), make_equal());
129 | }
130 | 
131 | GTEST_TEST(tuple, size_one) {
132 |   crust_static_assert(!Require<Tuple<A>, ZeroSizedType>::result);
133 | 
134 |   crust_static_assert(!Require<Tuple<A>, PartialEq>::result);
135 |   crust_static_assert(!Require<Tuple<A>, Eq>::result);
136 | 
137 |   crust_static_assert(std::is_trivially_copyable<Tuple<A>>::value);
138 | 
139 |   crust_static_assert(Require<Tuple<i32>, PartialEq>::result);
140 |   crust_static_assert(Require<Tuple<i32>, Eq>::result);
141 | 
142 |   crust_static_assert(tuple(0) == tuple(0));
143 |   crust_static_assert(!(tuple(0) != tuple(0)));
144 |   crust_static_assert(!(tuple(0) < tuple(0)));
145 |   crust_static_assert(tuple(0) <= tuple(0));
146 |   crust_static_assert(!(tuple(0) > tuple(0)));
147 |   crust_static_assert(tuple(0) >= tuple(0));
148 |   EXPECT_EQ(operator_partial_cmp(tuple(0), tuple(0)), make_some(make_equal()));
149 |   EXPECT_EQ(operator_cmp(tuple(0), tuple(0)), make_equal());
150 | 
151 |   auto value = tuple(0);
152 | 
153 |   EXPECT_EQ(value.get<0>(), 0);
154 | 
155 |   ++value.get<0>();
156 | 
157 |   EXPECT_EQ(value.get<0>(), 1);
158 | }
159 | 
160 | GTEST_TEST(tuple, size_two) {
161 |   crust_static_assert(!Require<Tuple<A, B>, ZeroSizedType>::result);
162 | 
163 |   crust_static_assert(!Require<Tuple<A, B>, PartialEq>::result);
164 |   crust_static_assert(!Require<Tuple<A, B>, Eq>::result);
165 | 
166 |   crust_static_assert(std::is_trivially_copyable<Tuple<A, B>>::value);
167 | 
168 |   crust_static_assert(Require<Tuple<i32, char>, PartialEq>::result);
169 |   crust_static_assert(Require<Tuple<i32, char>, Eq>::result);
170 | 
171 |   auto value = tuple(0, 'a');
172 | 
173 |   EXPECT_TRUE(value.get<0>() == 0);
174 |   EXPECT_TRUE(value.get<1>() == 'a');
175 | 
176 |   ++value.get<0>();
177 |   ++value.get<1>();
178 | 
179 |   EXPECT_TRUE(std::get<0>(value) == 1);
180 |   EXPECT_TRUE(std::get<1>(value) == 'b');
181 | 
182 |   crust_static_assert(tuple(true) != tuple(false));
183 |   crust_static_assert(tuple(1) > tuple(0));
184 |   crust_static_assert(tuple(0, 'b') > tuple(0, 'a'));
185 | 
186 |   EXPECT_TRUE(tuple(0, 1).cmp(tuple(0, 0)) == make_greater());
187 | }
188 | 
189 | GTEST_TEST(tuple, raii) {
190 |   auto recorder = std::make_shared<test::RAIIRecorder>(test::RAIIRecorder{});
191 | 
192 |   auto a = tuple(C{recorder}, D{recorder}, C{recorder}, D{recorder});
193 |   auto b = a;
194 |   auto c = clone::clone(a);
195 |   c.clone_from(b);
196 |   auto d = move(a);
197 | }
198 | 
199 | GTEST_TEST(tuple, tie) {
200 |   const auto tuple2 = tuple(1, 2);
201 |   const auto tuple7 = tuple(1, 2, 3, 4, 5, 6, 7);
202 | 
203 |   int a, b;
204 |   tie(a, b) = tuple(1, 2);
205 | 
206 |   EXPECT_EQ(a, 1);
207 |   EXPECT_EQ(b, 2);
208 | 
209 |   Ref<int> c, d;
210 |   tie(c, d) = tuple2;
211 | 
212 |   EXPECT_EQ(*c, 1);
213 |   EXPECT_EQ(*d, 2);
214 | 
215 |   int e, f;
216 |   tie(e, _) = tuple(1, 2);
217 |   tie(_, f) = tuple(1, 2);
218 | 
219 |   EXPECT_EQ(e, 1);
220 |   EXPECT_EQ(f, 2);
221 | 
222 |   int g, h;
223 |   Ref<int> i, j;
224 |   tie(g, i, _, __, h, j) = tuple7;
225 | 
226 |   EXPECT_EQ(g, 1);
227 |   EXPECT_EQ(*i, 2);
228 |   EXPECT_EQ(h, 6);
229 |   EXPECT_EQ(*j, 7);
230 | 
231 |   int k, l;
232 |   tie(k, __) = tuple(1, 2, 3, 4, 5, 6, 7);
233 |   tie(__, l) = tuple(1, 2, 3, 4, 5, 6, 7);
234 | 
235 |   EXPECT_EQ(k, 1);
236 |   EXPECT_EQ(l, 7);
237 | 
238 |   int m, n, o, p;
239 |   tie(tie(m, n), tie(o, p)) = tuple(tuple(1, 2), tuple(3, 4));
240 | 
241 |   EXPECT_EQ(m, 1);
242 |   EXPECT_EQ(n, 2);
243 |   EXPECT_EQ(o, 3);
244 |   EXPECT_EQ(p, 4);
245 | 
246 | #if __cplusplus > 201402L
247 |   auto [a1, b1] = tuple(1, 2);
248 | 
249 |   EXPECT_EQ(a1, 1);
250 |   EXPECT_EQ(b1, 2);
251 | #endif
252 | }
253 | 


--------------------------------------------------------------------------------
/include/crust/ops/function.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef CRUST_OPS_FUNCTION_HPP
  2 | #define CRUST_OPS_FUNCTION_HPP
  3 | 
  4 | 
  5 | #include "crust/tuple_decl.hpp"
  6 | #include "crust/utility.hpp"
  7 | 
  8 | 
  9 | namespace crust {
 10 | namespace ops {
 11 | namespace _impl_fn {
 12 | template <
 13 |     class Self,
 14 |     class F = decltype(&Self::operator()),
 15 |     F f = &Self::operator()>
 16 | struct MemFnClosure;
 17 | 
 18 | template <class Self, class Ret, class... Args, Ret (Self::*f)(Args...) const>
 19 | struct MemFnClosure<Self, Ret (Self::*)(Args...) const, f> :
 20 |     TmplType<Ret(Args...)> {};
 21 | 
 22 | template <class Self, class Ret, class... Args, Ret (Self::*f)(Args...)>
 23 | struct MemFnClosure<Self, Ret (Self::*)(Args...), f> :
 24 |     TmplType<Ret(Args...)> {};
 25 | 
 26 | template <class F, F f>
 27 | struct RawMemFn;
 28 | 
 29 | template <class Self, class Ret, class... Args, Ret (Self::*f)(Args...) const>
 30 | struct RawMemFn<Ret (Self::*)(Args...) const, f> {
 31 |   constexpr Ret operator()(const Self &self, Args... args) const {
 32 |     return (self.*f)(forward<Args>(args)...);
 33 |   }
 34 | };
 35 | 
 36 | template <class Self, class Ret, class... Args, Ret (Self::*f)(Args...)>
 37 | struct RawMemFn<Ret (Self::*)(Args...), f> {
 38 |   constexpr Ret operator()(Self &self, Args... args) const {
 39 |     return (self.*f)(forward<Args>(args)...);
 40 |   }
 41 | };
 42 | 
 43 | template <class F, F *f>
 44 | struct RawFn;
 45 | 
 46 | template <class Ret, class... Args, Ret (*f)(Args...)>
 47 | struct RawFn<Ret(Args...), f> {
 48 |   constexpr Ret operator()(Args... args) const {
 49 |     return f(forward<Args>(args)...);
 50 |   }
 51 | };
 52 | } // namespace _impl_fn
 53 | 
 54 | template <class Self, class F = typename _impl_fn::MemFnClosure<Self>::Result>
 55 | struct Fn;
 56 | 
 57 | template <class Self, class Ret, class... Args>
 58 | struct Fn<Self, Ret(Args...)> {
 59 | private:
 60 |   crust_static_assert(!IsConstOrRefVal<Self>::result);
 61 | 
 62 |   Self self;
 63 | 
 64 | public:
 65 |   constexpr Fn(Self &&self) : self{move(self)} {}
 66 | 
 67 |   constexpr Ret operator()(Args... args) const {
 68 |     return self(forward<Args>(args)...);
 69 |   }
 70 | };
 71 | 
 72 | template <class F, F *f>
 73 | crust_always_inline Fn<_impl_fn::RawFn<F, f>> bind(TmplVal<F *, f>) {
 74 |   return Fn<_impl_fn::RawFn<F, f>>{_impl_fn::RawFn<F, f>{}};
 75 | }
 76 | 
 77 | template <class T, class F, F *f>
 78 | crust_always_inline Fn<_impl_fn::RawFn<F, f>, T> bind(TmplVal<F *, f>) {
 79 |   return Fn<_impl_fn::RawFn<F, f>, T>{_impl_fn::RawFn<F, f>{}};
 80 | }
 81 | 
 82 | template <class F, F f>
 83 | crust_always_inline Fn<_impl_fn::RawMemFn<F, f>> bind(TmplVal<F, f>) {
 84 |   return Fn<_impl_fn::RawMemFn<F, f>>{_impl_fn::RawMemFn<F, f>{}};
 85 | }
 86 | 
 87 | template <class T, class F, F f>
 88 | crust_always_inline Fn<_impl_fn::RawMemFn<F, f>, T> bind(TmplVal<F, f>) {
 89 |   return Fn<_impl_fn::RawMemFn<F, f>, T>{_impl_fn::RawMemFn<F, f>{}};
 90 | }
 91 | 
 92 | template <class T>
 93 | crust_always_inline constexpr Fn<T> bind(T &&f) {
 94 |   return Fn<T>{forward<T>(f)};
 95 | }
 96 | 
 97 | template <class F, class T>
 98 | crust_always_inline constexpr Fn<T, F> bind(T &&f) {
 99 |   return Fn<T, F>{forward<T>(f)};
100 | }
101 | 
102 | template <class Self, class F = typename _impl_fn::MemFnClosure<Self>::Result>
103 | struct FnMut;
104 | 
105 | template <class Self, class Ret, class... Args>
106 | struct FnMut<Self, Ret(Args...)> {
107 | private:
108 |   crust_static_assert(!IsConstOrRefVal<Self>::result);
109 | 
110 |   Self self;
111 | 
112 | public:
113 |   constexpr FnMut(Self &&self) : self{move(self)} {}
114 | 
115 |   crust_cxx14_constexpr Ret operator()(Args... args) {
116 |     return self(forward<Args>(args)...);
117 |   }
118 | };
119 | 
120 | template <class F, F *f>
121 | crust_always_inline FnMut<_impl_fn::RawFn<F, f>> bind_mut(TmplVal<F *, f>) {
122 |   return FnMut<_impl_fn::RawFn<F, f>>{_impl_fn::RawFn<F, f>{}};
123 | }
124 | 
125 | template <class T, class F, F *f>
126 | crust_always_inline FnMut<_impl_fn::RawFn<F, f>, T> bind_mut(TmplVal<F *, f>) {
127 |   return FnMut<_impl_fn::RawFn<F, f>, T>{_impl_fn::RawFn<F, f>{}};
128 | }
129 | 
130 | template <class F, F f>
131 | crust_always_inline FnMut<_impl_fn::RawMemFn<F, f>> bind_mut(TmplVal<F, f>) {
132 |   return FnMut<_impl_fn::RawMemFn<F, f>>{_impl_fn::RawMemFn<F, f>{}};
133 | }
134 | 
135 | template <class T, class F, F f>
136 | crust_always_inline FnMut<_impl_fn::RawMemFn<F, f>, T> bind_mut(TmplVal<F, f>) {
137 |   return FnMut<_impl_fn::RawMemFn<F, f>, T>{_impl_fn::RawMemFn<F, f>{}};
138 | }
139 | 
140 | template <class T>
141 | crust_always_inline constexpr FnMut<T> bind_mut(T &&f) {
142 |   return FnMut<T>{forward<T>(f)};
143 | }
144 | 
145 | template <class F, class T>
146 | crust_always_inline constexpr FnMut<T, F> bind_mut(T &&f) {
147 |   return FnMut<T, F>{forward<T>(f)};
148 | }
149 | 
150 | namespace _impl_fn {
151 | template <class Base, class Self>
152 | struct DestructorStaticWrapper {
153 |   static crust_cxx14_constexpr void inner(Base *self) {
154 |     reinterpret_cast<Self *>(self)->~Self();
155 |   }
156 | };
157 | 
158 | template <class Ret, class... Args>
159 | struct FnVTable {
160 |   void (*drop)(void *);
161 |   usize size;
162 |   usize align;
163 |   Ret (*call)(const void *, Args...);
164 | };
165 | 
166 | template <class Self, class Ret, class... Args>
167 | struct StaticFnVTable {
168 |   static const FnVTable<Ret, Args...> vtable;
169 | 
170 |   static constexpr Ret call(const void *self, Args &&...args) {
171 |     return (*reinterpret_cast<const Self *>(self))(forward<Args>(args)...);
172 |   }
173 | };
174 | 
175 | template <class Self, class Ret, class... Args>
176 | const FnVTable<Ret, Args...> StaticFnVTable<Self, Ret, Args...>::vtable{
177 |     DestructorStaticWrapper<void, Self>::inner,
178 |     sizeof(Self),
179 |     alignof(Self),
180 |     call,
181 | };
182 | 
183 | template <class Ret, class... Args>
184 | struct FnMutVTable {
185 |   void (*drop)(void *);
186 |   usize size;
187 |   usize align;
188 |   Ret (*call)(void *, Args...);
189 | };
190 | 
191 | template <class Self, class Ret, class... Args>
192 | struct StaticFnMutVTable {
193 |   static const FnMutVTable<Ret, Args...> vtable;
194 | 
195 |   static crust_cxx14_constexpr Ret call(void *self, Args... args) {
196 |     return (*reinterpret_cast<Self *>(self))(forward<Args>(args)...);
197 |   }
198 | };
199 | 
200 | template <class Self, class Ret, class... Args>
201 | const FnMutVTable<Ret, Args...> StaticFnMutVTable<Self, Ret, Args...>::vtable{
202 |     DestructorStaticWrapper<void, Self>::inner,
203 |     sizeof(Self),
204 |     alignof(Self),
205 |     call,
206 | };
207 | } // namespace _impl_fn
208 | 
209 | template <class F>
210 | struct DynFn;
211 | 
212 | template <class F>
213 | struct DynFnMut;
214 | 
215 | template <class Ret, class... Args>
216 | struct DynFn<Ret(Args...)> { // TODO: optimize for zero sized type
217 | private:
218 |   void *self;
219 |   const _impl_fn::FnVTable<Ret, Args...> *vtable;
220 | 
221 |   void drop() {
222 |     if (self != nullptr) {
223 |       vtable->drop(self);
224 |       delete reinterpret_cast<char *>(self);
225 |       self = nullptr;
226 |     }
227 |   }
228 | 
229 |   void move_from(DynFn &&other) {
230 |     self = other.self;
231 |     vtable = other.vtable;
232 |     other.self = nullptr;
233 |   }
234 | 
235 | public:
236 |   template <class Self>
237 |   constexpr DynFn(Self &&self) :
238 |       self{new Self{forward<Self>(self)}},
239 |       vtable{&_impl_fn::StaticFnVTable<Self, Ret, Args...>::vtable} {}
240 | 
241 |   template <class F, F *f>
242 |   constexpr DynFn(TmplVal<F *, f>) : DynFn{_impl_fn::RawFn<F, f>{}} {}
243 | 
244 |   DynFn(DynFn &&other) noexcept { move_from(move(other)); }
245 | 
246 |   DynFn &operator=(DynFn &&other) noexcept {
247 |     if (this != &other) {
248 |       drop();
249 |       move_from(move(other));
250 |     }
251 | 
252 |     return *this;
253 |   }
254 | 
255 |   constexpr Ret operator()(Args &&...args) const {
256 |     return vtable->call(self, forward<Args>(args)...);
257 |   }
258 | 
259 |   ~DynFn() { drop(); }
260 | };
261 | 
262 | template <class Ret, class... Args>
263 | struct DynFnMut<Ret(Args...)> {
264 | private:
265 |   void *self;
266 |   const _impl_fn::FnMutVTable<Ret, Args...> *vtable;
267 | 
268 |   void drop() {
269 |     if (self != nullptr) {
270 |       vtable->drop(self);
271 |       delete reinterpret_cast<char *>(self);
272 |       self = nullptr;
273 |     }
274 |   }
275 | 
276 |   void move_from(DynFnMut &&other) {
277 |     self = other.self;
278 |     vtable = other.vtable;
279 |     other.self = nullptr;
280 |   }
281 | 
282 | public:
283 |   template <class Self>
284 |   constexpr DynFnMut(Self &&self) :
285 |       self{new Self{forward<Self>(self)}},
286 |       vtable{&_impl_fn::StaticFnMutVTable<Self, Ret, Args...>::vtable} {}
287 | 
288 |   template <class F, F *f>
289 |   constexpr DynFnMut(TmplVal<F *, f>) : DynFnMut{_impl_fn::RawFn<F, f>{}} {}
290 | 
291 |   DynFnMut(DynFnMut &&other) noexcept { move_from(move(other)); }
292 | 
293 |   DynFnMut &operator=(DynFnMut &&other) noexcept {
294 |     if (this != &other) {
295 |       drop();
296 |       move_from(move(other));
297 |     }
298 | 
299 |     return *this;
300 |   }
301 | 
302 |   crust_cxx14_constexpr Ret operator()(Args... args) {
303 |     return vtable->call(self, forward<Args>(args)...);
304 |   }
305 | 
306 |   ~DynFnMut() { drop(); }
307 | };
308 | } // namespace ops
309 | } // namespace crust
310 | 
311 | 
312 | #endif // CRUST_OPS_FUNCTION_HPP
313 | 


--------------------------------------------------------------------------------
/include/crust/tuple.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef CRUST_TUPLE_HPP
  2 | #define CRUST_TUPLE_HPP
  3 | 
  4 | 
  5 | #include "tuple_decl.hpp"
  6 | 
  7 | #include <utility>
  8 | 
  9 | #include "crust/cmp.hpp"
 10 | #include "crust/option.hpp"
 11 | 
 12 | 
 13 | namespace crust {
 14 | template <class S>
 15 | constexpr Option<cmp::Ordering> ImplFor<
 16 |     cmp::PartialOrd<S>,
 17 |     EnableIf<_impl_derive::ImplForTupleStruct<S, cmp::PartialOrd>>>::
 18 |     partial_cmp(const Self &other) const {
 19 |   return PartialOrdHelper::partial_cmp(self(), other);
 20 | }
 21 | 
 22 | template <class S>
 23 | constexpr cmp::Ordering
 24 | ImplFor<cmp::Ord<S>, EnableIf<_impl_derive::ImplForTupleStruct<S, cmp::Ord>>>::
 25 |     cmp(const Self &other) const {
 26 |   return OrdHelper::cmp(self(), other);
 27 | }
 28 | 
 29 | template <class... Fields>
 30 | constexpr Tuple<typename RemoveConstOrRefType<Fields>::Result...>
 31 | tuple(Fields &&...fields) {
 32 |   return Tuple<typename RemoveConstOrRefType<Fields>::Result...>{
 33 |       forward<Fields>(fields)...};
 34 | }
 35 | 
 36 | namespace _impl_tuple {
 37 | template <class... Fields>
 38 | struct TieTuple;
 39 | 
 40 | template <class T>
 41 | struct LetField {
 42 |   T *ptr;
 43 | 
 44 |   constexpr LetField(T &ref) : ptr{&ref} {}
 45 | 
 46 |   crust_cxx14_constexpr void assign_ref(const T &other) { *ptr = other; }
 47 | 
 48 |   crust_cxx14_constexpr void assign_ref_mut(T &other) { *ptr = other; }
 49 | 
 50 |   crust_cxx14_constexpr void assign_move(T &&other) { *ptr = move(other); }
 51 | };
 52 | 
 53 | template <class... Fields>
 54 | struct LetField<TieTuple<Fields...>> {
 55 |   TieTuple<Fields...> fields;
 56 | 
 57 |   constexpr LetField(TieTuple<Fields...> &&fields) : fields{move(fields)} {}
 58 | 
 59 |   template <class T>
 60 |   crust_cxx14_constexpr void assign_ref(const T &other) {
 61 |     fields = other;
 62 |   }
 63 | 
 64 |   template <class T>
 65 |   crust_cxx14_constexpr void assign_ref_mut(T &other) {
 66 |     fields = other;
 67 |   }
 68 | 
 69 |   template <class T>
 70 |   crust_cxx14_constexpr void assign_move(T &&other) {
 71 |     fields = move(other);
 72 |   }
 73 | };
 74 | 
 75 | template <>
 76 | struct LetField<_impl_utility::Ignore> {
 77 |   constexpr LetField(const _impl_utility::Ignore &) {}
 78 | 
 79 |   template <class T>
 80 |   crust_cxx14_constexpr void assign_ref(const T &) const {}
 81 | 
 82 |   template <class T>
 83 |   crust_cxx14_constexpr void assign_ref_mut(T &) const {}
 84 | 
 85 |   template <class T>
 86 |   crust_cxx14_constexpr void assign_move(T &&) const {}
 87 | };
 88 | 
 89 | template <>
 90 | struct LetField<_impl_utility::IgnoreRange> {
 91 |   constexpr LetField(const _impl_utility::IgnoreRange &) {}
 92 | 
 93 |   template <class T>
 94 |   crust_cxx14_constexpr void assign_ref(const T &) const {}
 95 | 
 96 |   template <class T>
 97 |   crust_cxx14_constexpr void assign_ref_mut(T &) const {}
 98 | 
 99 |   template <class T>
100 |   crust_cxx14_constexpr void assign_move(T &&) const {}
101 | };
102 | 
103 | template <class T>
104 | struct LetField<Ref<T>> {
105 |   Ref<T> *ptr;
106 | 
107 |   constexpr LetField(Ref<T> &ref) : ptr{&ref} {}
108 | 
109 |   crust_cxx14_constexpr void assign_ref(const Ref<T> &other) { *ptr = other; }
110 | 
111 |   crust_cxx14_constexpr void assign_ref_mut(Ref<T> &other) { *ptr = other; }
112 | 
113 |   crust_cxx14_constexpr void assign_move(Ref<T> &&other) { *ptr = move(other); }
114 | 
115 |   crust_cxx14_constexpr void assign_ref(const T &other) { *ptr = ref(other); }
116 | 
117 |   crust_cxx14_constexpr void assign_ref_mut(T &other) { *ptr = ref(other); }
118 | };
119 | 
120 | template <class T>
121 | struct LetField<RefMut<T>> {
122 |   RefMut<T> *ptr;
123 | 
124 |   constexpr LetField(RefMut<T> &ref) : ptr{&ref} {}
125 | 
126 |   crust_cxx14_constexpr void assign_ref(const RefMut<T> &other) {
127 |     *ptr = other;
128 |   }
129 | 
130 |   crust_cxx14_constexpr void assign_ref_mut(RefMut<T> &other) { *ptr = other; }
131 | 
132 |   crust_cxx14_constexpr void assign_move(RefMut<T> &&other) {
133 |     *ptr = move(other);
134 |   }
135 | 
136 |   crust_cxx14_constexpr void assign(RefMut<T> &other) { *ptr = move(other); }
137 | 
138 |   crust_cxx14_constexpr void assign_ref_mut(T &other) { *ptr = ref_mut(other); }
139 | };
140 | 
141 | template <bool is_range, usize r1_idx, usize r2_idx, class Self, class Base>
142 | struct TieTupleHelperRemain;
143 | 
144 | template <usize r1_idx, usize r2_idx, class Self, class Base>
145 | struct TieTupleHelper {
146 |   static constexpr usize index1 =
147 |       _impl_derive::TupleLikeSize<Self>::result - r1_idx;
148 |   static constexpr usize index2 =
149 |       _impl_derive::TupleLikeSize<Base>::result - r2_idx;
150 |   using Getter = _impl_derive::TupleLikeGetter<Base, index2>;
151 |   using This = typename _impl_derive::TupleLikeGetter<Self, index1>::Result;
152 |   static constexpr bool is_range =
153 |       IsSame<This, LetField<_impl_utility::IgnoreRange>>::result;
154 |   using Remains =
155 |       typename TieTupleHelperRemain<is_range, r1_idx, r2_idx, Self, Base>::
156 |           Result;
157 | 
158 |   static crust_cxx14_constexpr void assign_ref(Self &ref, const Base &tuple) {
159 |     ref.template get<index1>().assign_ref(Getter::get(tuple));
160 |     Remains::assign_ref(ref, tuple);
161 |   }
162 | 
163 |   static crust_cxx14_constexpr void assign_ref_mut(Self &ref, Base &tuple) {
164 |     ref.template get<index1>().assign_ref_mut(Getter::get(tuple));
165 |     Remains::assign_ref_mut(ref, tuple);
166 |   }
167 | 
168 |   static crust_cxx14_constexpr void assign_move(Self &ref, Base &&tuple) {
169 |     ref.template get<index1>().assign_move(move(Getter::get(tuple)));
170 |     Remains::assign_move(ref, move(tuple));
171 |   }
172 | };
173 | 
174 | template <class Self, class Base>
175 | struct TieTupleHelper<0, 0, Self, Base> {
176 |   static crust_cxx14_constexpr void assign_ref(Self &, const Base &) {}
177 | 
178 |   static crust_cxx14_constexpr void assign_ref_mut(Self &, Base &) {}
179 | 
180 |   static crust_cxx14_constexpr void assign_move(Self &, Base &&) {}
181 | };
182 | 
183 | template <usize r1_idx, usize r2_idx, class Self, class Base>
184 | struct TieTupleHelperRemain<false, r1_idx, r2_idx, Self, Base> :
185 |     TmplType<TieTupleHelper<r1_idx - 1, r2_idx - 1, Self, Base>> {};
186 | 
187 | template <usize r1_idx, usize r2_idx, class Self, class Base>
188 | struct TieTupleHelperRemain<true, r1_idx, r2_idx, Self, Base> :
189 |     TmplType<TieTupleHelper<r1_idx - 1, r1_idx - 1, Self, Base>> {};
190 | 
191 | template <class... Fields>
192 | struct TieTuple {
193 | private:
194 |   crust_static_assert(!Any<IsConstOrRefVal<Fields>...>::result);
195 |   crust_static_assert(
196 |       _impl_types::TypesCountType<
197 |           _impl_utility::IgnoreRange,
198 |           _impl_types::Types<Fields...>>::result <= 1);
199 | 
200 |   Tuple<LetField<Fields>...> ref;
201 | 
202 | public:
203 |   template <class... Fs>
204 |   explicit constexpr TieTuple(Fs &&...fields) :
205 |       ref{LetField<Fields>{forward<Fs>(fields)}...} {}
206 | 
207 |   template <class... Fs>
208 |   crust_cxx14_constexpr void operator=(const TupleStruct<Fs...> &tuple) {
209 |     TieTupleHelper<
210 |         sizeof...(Fields),
211 |         sizeof...(Fs),
212 |         TupleStruct<LetField<Fields>...>,
213 |         TupleStruct<Fs...>>::assign_ref(ref, tuple);
214 |   }
215 | 
216 |   template <class... Fs>
217 |   crust_cxx14_constexpr void operator=(TupleStruct<Fs...> &tuple) {
218 |     TieTupleHelper<
219 |         sizeof...(Fields),
220 |         sizeof...(Fs),
221 |         TupleStruct<LetField<Fields>...>,
222 |         TupleStruct<Fs...>>::assign_ref_mut(ref, tuple);
223 |   }
224 | 
225 |   template <class... Fs>
226 |   crust_cxx14_constexpr void operator=(TupleStruct<Fs...> &&tuple) {
227 |     TieTupleHelper<
228 |         sizeof...(Fields),
229 |         sizeof...(Fs),
230 |         TupleStruct<LetField<Fields>...>,
231 |         TupleStruct<Fs...>>::assign_move(ref, move(tuple));
232 |   }
233 | };
234 | } // namespace _impl_tuple
235 | 
236 | template <class... Fields>
237 | crust_cxx14_constexpr
238 |     _impl_tuple::TieTuple<typename RemoveConstOrRefType<Fields>::Result...>
239 |     tie(Fields &&...fields) {
240 |   return _impl_tuple::TieTuple<
241 |       typename RemoveConstOrRefType<Fields>::Result...>{
242 |       forward<Fields>(fields)...};
243 | }
244 | } // namespace crust
245 | 
246 | namespace std {
247 | 
248 | /// c++ std bindings
249 | 
250 | template <class... Fields>
251 | struct tuple_size<crust::Tuple<Fields...>> :
252 |     integral_constant<
253 |         crust::usize,
254 |         crust::_impl_derive::TupleLikeSize<
255 |             crust::TupleStruct<Fields...>>::result> {};
256 | 
257 | template <crust::usize index, class... Fields>
258 | struct tuple_element<index, crust::Tuple<Fields...>> {
259 |   using type = typename crust::_impl_derive::
260 |       TupleLikeGetter<crust::TupleStruct<Fields...>, index>::Result;
261 | };
262 | 
263 | template <crust::usize index, class... Fields>
264 | constexpr const typename tuple_element<index, crust::Tuple<Fields...>>::type &
265 | get(const crust::TupleStruct<Fields...> &object) {
266 |   return crust::_impl_derive::
267 |       TupleLikeGetter<crust::TupleStruct<Fields...>, index>::get(object);
268 | }
269 | 
270 | template <crust::usize index, class... Fields>
271 | constexpr typename tuple_element<index, crust::Tuple<Fields...>>::type &
272 | get(crust::TupleStruct<Fields...> &object) {
273 |   return crust::_impl_derive::
274 |       TupleLikeGetter<crust::TupleStruct<Fields...>, index>::get(object);
275 | }
276 | } // namespace std
277 | 
278 | 
279 | #endif // CRUST_TUPLE_HPP
280 | 


--------------------------------------------------------------------------------
/include/crust/cmp.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef CRUST_CMP_HPP
  2 | #define CRUST_CMP_HPP
  3 | 
  4 | 
  5 | #include "cmp_decl.hpp"
  6 | 
  7 | #include "crust/enum_decl.hpp"
  8 | #include "crust/option.hpp"
  9 | #include "crust/utility.hpp"
 10 | 
 11 | 
 12 | namespace crust {
 13 | namespace cmp {
 14 | struct Less;
 15 | struct Equal;
 16 | struct Greater;
 17 | struct Ordering;
 18 | } // namespace cmp
 19 | 
 20 | template <>
 21 | struct BluePrint<cmp::Less> : TmplType<TupleStruct<>> {};
 22 | 
 23 | template <>
 24 | struct BluePrint<cmp::Equal> : TmplType<TupleStruct<>> {};
 25 | 
 26 | template <>
 27 | struct BluePrint<cmp::Greater> : TmplType<TupleStruct<>> {};
 28 | 
 29 | template <>
 30 | struct BluePrint<cmp::Ordering> :
 31 |     TmplType<Enum<cmp::Less, cmp::Equal, cmp::Greater>> {};
 32 | 
 33 | namespace cmp {
 34 | CRUST_DISCRIMINANT_VARIANT(Less, -1);
 35 | CRUST_DISCRIMINANT_VARIANT(Equal, 0);
 36 | CRUST_DISCRIMINANT_VARIANT(Greater, 1);
 37 | 
 38 | struct crust_ebco Ordering :
 39 |     Enum<EnumRepr<i8>, Less, Equal, Greater>,
 40 |     Derive<
 41 |         Ordering,
 42 |         Trait<cmp::PartialEq>,
 43 |         Trait<cmp::Eq>,
 44 |         Trait<cmp::PartialOrd>,
 45 |         Trait<cmp::Ord>> {
 46 |   CRUST_ENUM_USE_BASE(Ordering, Enum<EnumRepr<i8>, Less, Equal, Greater>);
 47 | 
 48 |   crust_cxx17_constexpr Ordering reverse() const {
 49 |     return this->template visit<Ordering>(
 50 |         [](const Less &) { return Greater{}; },
 51 |         [](const Equal &) { return Equal{}; },
 52 |         [](const Greater &) { return Less{}; });
 53 |   }
 54 | 
 55 |   crust_cxx17_constexpr Ordering then(const Ordering &other) const {
 56 |     return this->template visit<Ordering>(
 57 |         [](const Less &) { return Less{}; },
 58 |         [&](const Equal &) { return other; },
 59 |         [](const Greater &) { return Greater{}; });
 60 |   }
 61 | 
 62 |   template <class F>
 63 |   constexpr Ordering then_with(ops::Fn<F, Ordering()> f) const {
 64 |     return this->template visit<Ordering>(
 65 |         [](const Less &) { return Less{}; },
 66 |         [&](const Equal &) { return f(); },
 67 |         [](const Greater &) { return Greater{}; });
 68 |   }
 69 | };
 70 | 
 71 | crust_always_inline constexpr Ordering make_less() { return Less{}; }
 72 | 
 73 | crust_always_inline constexpr Ordering make_equal() { return Equal{}; }
 74 | 
 75 | crust_always_inline constexpr Ordering make_greater() { return Greater{}; }
 76 | } // namespace cmp
 77 | 
 78 | /// because c++ do not support add member function for primitive types,
 79 | /// following two functions are used for invoking `partial_cmp' or `cmp' for
 80 | /// both struct implemented `PartialOrd' or `Ord' trait and primitive types.
 81 | template <class T, class U>
 82 | crust_always_inline constexpr Option<cmp::Ordering>
 83 | operator_partial_cmp(const T &v1, const U &v2) {
 84 |   return v1.partial_cmp(v2);
 85 | }
 86 | 
 87 | template <class T>
 88 | crust_always_inline constexpr cmp::Ordering
 89 | operator_cmp(const T &v1, const T &v2) {
 90 |   return v1.cmp(v2);
 91 | }
 92 | 
 93 | #define _IMPL_PRIMITIVE(FN, ...)                                               \
 94 |   template <>                                                                  \
 95 |   FN(bool, ##__VA_ARGS__);                                                     \
 96 |   template <>                                                                  \
 97 |   FN(char, ##__VA_ARGS__);                                                     \
 98 |   template <>                                                                  \
 99 |   FN(u8, ##__VA_ARGS__);                                                       \
100 |   template <>                                                                  \
101 |   FN(i8, ##__VA_ARGS__);                                                       \
102 |   template <>                                                                  \
103 |   FN(u16, ##__VA_ARGS__);                                                      \
104 |   template <>                                                                  \
105 |   FN(i16, ##__VA_ARGS__);                                                      \
106 |   template <>                                                                  \
107 |   FN(u32, ##__VA_ARGS__);                                                      \
108 |   template <>                                                                  \
109 |   FN(i32, ##__VA_ARGS__);                                                      \
110 |   template <>                                                                  \
111 |   FN(u64, ##__VA_ARGS__);                                                      \
112 |   template <>                                                                  \
113 |   FN(i64, ##__VA_ARGS__);                                                      \
114 |   template <class T>                                                           \
115 |   FN(T *, ##__VA_ARGS__)
116 | 
117 | #define _IMPL_OPERATOR_CMP(type, ...)                                          \
118 |   crust_always_inline constexpr cmp::Ordering operator_cmp(                    \
119 |       const type &v1, const type &v2) {                                        \
120 |     return v1 < v2 ? cmp::make_less() :                                        \
121 |                      (v1 > v2 ? cmp::make_greater() : cmp::make_equal());      \
122 |   }
123 | 
124 | _IMPL_PRIMITIVE(_IMPL_OPERATOR_CMP);
125 | 
126 | #undef _IMPL_OPERATOR_CMP
127 | 
128 | #define _IMPL_OPERATOR_PARTIAL_CMP(type, ...)                                  \
129 |   crust_always_inline constexpr Option<cmp::Ordering> operator_partial_cmp(    \
130 |       const type &v1, const type &v2) {                                        \
131 |     return make_some(operator_cmp(v1, v2));                                    \
132 |   }
133 | 
134 | _IMPL_PRIMITIVE(_IMPL_OPERATOR_PARTIAL_CMP);
135 | 
136 | #undef _IMPL_OPERATOR_PARTIAL_CMP
137 | 
138 | namespace cmp {
139 | // TODO: refactor
140 | template <class Self, class Rhs>
141 | constexpr bool PartialOrd<Self, Rhs>::lt(const Rhs &other) const {
142 |   return operator_partial_cmp(self(), other) == make_some(make_less());
143 | }
144 | 
145 | template <class Self, class Rhs>
146 | constexpr bool PartialOrd<Self, Rhs>::le(const Rhs &other) const {
147 |   return operator_partial_cmp(self(), other) == make_some(make_greater()) ||
148 |       operator_partial_cmp(self(), other) == make_some(make_equal());
149 | }
150 | 
151 | template <class Self, class Rhs>
152 | constexpr bool PartialOrd<Self, Rhs>::gt(const Rhs &other) const {
153 |   return operator_partial_cmp(self(), other) == make_some(make_greater());
154 | }
155 | 
156 | template <class Self, class Rhs>
157 | constexpr bool PartialOrd<Self, Rhs>::ge(const Rhs &other) const {
158 |   return operator_partial_cmp(self(), other) == make_some(make_greater()) ||
159 |       operator_partial_cmp(self(), other) == make_some(make_equal());
160 | }
161 | 
162 | template <class T>
163 | constexpr T min(T &&v1, T &&v2) {
164 |   crust_static_assert(Require<T, Ord>::result);
165 |   return move(v1).min(forward<T>(v2));
166 | }
167 | 
168 | template <class T, class F>
169 | constexpr T
170 | min_by(T &&v1, T &&v2, ops::Fn<F, Ordering(const T &, const T &)> compare) {
171 |   crust_static_assert(Require<T, Ord>::result);
172 |   return compare(v1, v2) == make_greater() ? forward<T>(v2) : forward<T>(v1);
173 | }
174 | 
175 | template <class T, class F, class K>
176 | constexpr T min_by_key(T &&v1, T &&v2, ops::Fn<F, K(const T &)> f) {
177 |   crust_static_assert(Require<T, Ord>::result);
178 |   return min_by(
179 |       forward<T>(v1), forward<T>(v2), ops::bind([&](const T &v1, const T &v2) {
180 |         return operator_cmp(f(v1), f(v2));
181 |       }));
182 | }
183 | 
184 | template <class T>
185 | constexpr T max(T &&v1, T &&v2) {
186 |   crust_static_assert(Require<T, Ord>::result);
187 |   return move(v1).max(forward<T>(v2));
188 | }
189 | 
190 | template <class T, class F>
191 | constexpr T
192 | max_by(T &&v1, T &&v2, ops::Fn<F, Ordering(const T &, const T &)> compare) {
193 |   crust_static_assert(Require<T, Ord>::result);
194 |   return compare(v1, v2) == make_greater() ? forward<T>(v1) : forward<T>(v2);
195 | }
196 | 
197 | template <class T, class F, class K>
198 | constexpr T max_by_key(T &&v1, T &&v2, ops::Fn<F, K(const T &)> f) {
199 |   crust_static_assert(Require<T, Ord>::result);
200 |   return max_by(
201 |       forward<T>(v1), forward<T>(v2), ops::bind([&](const T &v1, const T &v2) {
202 |         return operator_cmp(f(v1), f(v2));
203 |       }));
204 | }
205 | 
206 | template <class T>
207 | struct crust_ebco Reverse :
208 |     TupleStruct<T>,
209 |     Derive<Reverse<T>, Trait<ZeroSizedType>>,
210 |     Impl<
211 |         Reverse<T>,
212 |         Trait<PartialEq>,
213 |         Trait<Eq>,
214 |         Trait<PartialOrd>,
215 |         Trait<Ord>> {
216 |   CRUST_USE_BASE_CONSTRUCTORS(Reverse, TupleStruct<T>);
217 | };
218 | } // namespace cmp
219 | 
220 | template <class T>
221 | CRUST_IMPL_FOR(cmp::PartialEq<cmp::Reverse<T>>, Require<T, cmp::PartialEq>) {
222 |   CRUST_IMPL_USE_SELF(cmp::Reverse<T>);
223 | 
224 |   constexpr bool eq(const Self &other) const {
225 |     return other.template get<0>() == self().template get<0>();
226 |   }
227 | };
228 | 
229 | template <class T>
230 | CRUST_IMPL_FOR(cmp::Eq<cmp::Reverse<T>>, Require<T, cmp::Eq>){};
231 | 
232 | template <class T>
233 | CRUST_IMPL_FOR(cmp::PartialOrd<cmp::Reverse<T>>, Require<T, cmp::PartialOrd>) {
234 |   CRUST_IMPL_USE_SELF(cmp::Reverse<T>);
235 | 
236 |   constexpr Option<cmp::Ordering> partial_cmp(const Self &other) const {
237 |     return operator_partial_cmp(
238 |         other.template get<0>(), self().template get<0>());
239 |   }
240 | 
241 |   constexpr bool lt(const Self &other) const {
242 |     return other.template get<0>() < self().template get<0>();
243 |   }
244 | 
245 |   constexpr bool le(const Self &other) const {
246 |     return other.template get<0>() <= self().template get<0>();
247 |   }
248 | 
249 |   constexpr bool gt(const Self &other) const {
250 |     return other.template get<0>() > self().template get<0>();
251 |   }
252 | 
253 |   constexpr bool ge(const Self &other) const {
254 |     return other.template get<0>() >= self().template get<0>();
255 |   }
256 | };
257 | 
258 | template <class T>
259 | CRUST_IMPL_FOR(cmp::Ord<cmp::Reverse<T>>, Require<T, cmp::Ord>) {
260 |   CRUST_IMPL_USE_SELF(cmp::Reverse<T>);
261 | 
262 |   constexpr cmp::Ordering cmp(const Self &other) const {
263 |     return operator_cmp(other.template get<0>(), self().template get<0>());
264 |   }
265 | };
266 | 
267 | #define _DERIVE_PRIMITIVE(PRIMITIVE, TRAIT, ...)                               \
268 |   struct Require<PRIMITIVE, TRAIT, ##__VA_ARGS__> : BoolVal<true> {}
269 | 
270 | _IMPL_PRIMITIVE(_DERIVE_PRIMITIVE, cmp::PartialEq);
271 | _IMPL_PRIMITIVE(_DERIVE_PRIMITIVE, cmp::Eq);
272 | _IMPL_PRIMITIVE(_DERIVE_PRIMITIVE, cmp::PartialOrd);
273 | _IMPL_PRIMITIVE(_DERIVE_PRIMITIVE, cmp::Ord);
274 | 
275 | #undef _DERIVE_PRIMITIVE
276 | #undef _IMPL_PRIMITIVE
277 | 
278 | // TODO: implement for float point numbers
279 | 
280 | namespace _impl_derive {
281 | template <class Self, class Base, usize rev_index>
282 | constexpr Option<cmp::Ordering>
283 | TupleLikePartialOrdHelper<Self, Base, rev_index>::partial_cmp(
284 |     const Self &a, const Self &b) {
285 |   return make_some(operator_cmp(a, b)); // FIXME: temporary implement
286 | }
287 | 
288 | template <class Self, class Base>
289 | constexpr Option<cmp::Ordering>
290 | TupleLikePartialOrdHelper<Self, Base, 0>::partial_cmp(
291 |     const Self &, const Self &) {
292 |   return make_some(cmp::make_equal());
293 | }
294 | 
295 | template <class Self, class Base, usize rev_index>
296 | constexpr cmp::Ordering
297 | TupleLikeOrdHelper<Self, Base, rev_index>::cmp(const Self &a, const Self &b) {
298 |   return operator_cmp(Getter::get(a), Getter::get(b)).then(Remains::cmp(a, b));
299 | }
300 | 
301 | template <class Self, class Base>
302 | constexpr cmp::Ordering
303 | TupleLikeOrdHelper<Self, Base, 0>::cmp(const Self &, const Self &) {
304 |   return cmp::make_equal();
305 | }
306 | } // namespace _impl_derive
307 | } // namespace crust
308 | 
309 | 
310 | #endif // CRUST_CMP_HPP
311 | 


--------------------------------------------------------------------------------
/include/crust/tuple_decl.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef CRUST_TUPLE_DECL_HPP
  2 | #define CRUST_TUPLE_DECL_HPP
  3 | 
  4 | 
  5 | #include "crust/clone.hpp"
  6 | #include "crust/cmp_decl.hpp"
  7 | #include "crust/helper/types.hpp"
  8 | #include "crust/utility.hpp"
  9 | 
 10 | 
 11 | namespace crust {
 12 | namespace _impl_tuple {
 13 | template <class Ts>
 14 | struct AllZeroSizedType;
 15 | 
 16 | template <class... Fields>
 17 | struct AllZeroSizedType<_impl_types::Types<Fields...>> :
 18 |     All<Require<Fields, ZeroSizedType>...> {};
 19 | 
 20 | template <bool is_zst, bool remain_is_zst, class Ts>
 21 | struct TupleSizedHolderImpl;
 22 | 
 23 | template <class Ts>
 24 | using TupleSizedHolderIsZST =
 25 |     Require<typename _impl_types::TypesIndex<0, Ts>::Result, ZeroSizedType>;
 26 | 
 27 | template <class Ts>
 28 | using TupleSizedHolderRemainZST =
 29 |     AllZeroSizedType<typename _impl_types::TypesAfter<0, Ts>::Result>;
 30 | 
 31 | template <class... Fields>
 32 | using TupleSizedHolder = TupleSizedHolderImpl<
 33 |     TupleSizedHolderIsZST<_impl_types::Types<Fields...>>::result,
 34 |     TupleSizedHolderRemainZST<_impl_types::Types<Fields...>>::result,
 35 |     _impl_types::Types<Fields...>>;
 36 | 
 37 | template <class Field, class... Fields>
 38 | struct TupleSizedHolderImpl<
 39 |     false,
 40 |     false,
 41 |     _impl_types::Types<Field, Fields...>> {
 42 |   Field field;
 43 |   TupleSizedHolder<Fields...> remains;
 44 | 
 45 |   constexpr TupleSizedHolderImpl() : field{}, remains{} {}
 46 | 
 47 |   template <class T, class... Ts>
 48 |   explicit constexpr TupleSizedHolderImpl(T &&field, Ts &&...fields) :
 49 |       field{forward<T>(field)}, remains{forward<Ts>(fields)...} {}
 50 | };
 51 | 
 52 | template <class Field, class... Fields>
 53 | struct TupleSizedHolderImpl<false, true, _impl_types::Types<Field, Fields...>> {
 54 |   Field field;
 55 | 
 56 |   constexpr TupleSizedHolderImpl() : field{} {}
 57 | 
 58 |   explicit constexpr TupleSizedHolderImpl(Field &&field, Fields &&...) :
 59 |       field{forward<Field>(field)} {}
 60 | };
 61 | 
 62 | template <class Field, class... Fields>
 63 | struct TupleSizedHolderImpl<true, false, _impl_types::Types<Field, Fields...>> {
 64 |   TupleSizedHolder<Fields...> remains;
 65 | 
 66 |   constexpr TupleSizedHolderImpl() : remains{} {}
 67 | 
 68 |   explicit constexpr TupleSizedHolderImpl(Field &&, Fields &&...fields) :
 69 |       remains{forward<Fields>(fields)...} {}
 70 | };
 71 | 
 72 | template <class... Fields>
 73 | struct TupleSizedHolderImpl<true, true, _impl_types::Types<Fields...>> {
 74 |   constexpr TupleSizedHolderImpl() {}
 75 | 
 76 |   explicit constexpr TupleSizedHolderImpl(Fields &&...) {}
 77 | };
 78 | 
 79 | template <usize index, bool is_zst, class... Fields>
 80 | struct TupleGetterImpl;
 81 | 
 82 | template <usize index, class... Fields>
 83 | struct TupleGetterImpl<index, true, Fields...> :
 84 |     _impl_types::ZeroSizedTypeGetter<index, Fields...> {};
 85 | 
 86 | template <usize index, class Field, class... Fields>
 87 | struct TupleGetterImpl<index, false, Field, Fields...> {
 88 |   using Self = TupleSizedHolder<Field, Fields...>;
 89 |   using Result = typename _impl_types::
 90 |       TypesIndex<index, _impl_types::Types<Field, Fields...>>::Result;
 91 | 
 92 |   static constexpr const Result &inner(const Self &self) {
 93 |     return TupleGetterImpl<index - 1, false, Fields...>::inner(self.remains);
 94 |   }
 95 | 
 96 |   static constexpr Result &inner(Self &self) {
 97 |     return TupleGetterImpl<index - 1, false, Fields...>::inner(self.remains);
 98 |   }
 99 | };
100 | 
101 | template <class Field, class... Fields>
102 | struct TupleGetterImpl<0, false, Field, Fields...> {
103 |   using Self = TupleSizedHolder<Field, Fields...>;
104 |   using Result = Field;
105 | 
106 |   static constexpr const Result &inner(const Self &self) { return self.field; }
107 | 
108 |   static constexpr Result &inner(Self &self) { return self.field; }
109 | };
110 | 
111 | template <usize index, class... Fields>
112 | using TupleGetter = TupleGetterImpl<
113 |     index,
114 |     Require<
115 |         typename _impl_types::TypesIndex<index, _impl_types::Types<Fields...>>::
116 |             Result,
117 |         ZeroSizedType>::result,
118 |     Fields...>;
119 | } // namespace _impl_tuple
120 | 
121 | template <class... Fields>
122 | struct TupleStruct :
123 |     private _impl_types::ZeroSizedTypeHolder<Fields...>,
124 |     private _impl_tuple::TupleSizedHolder<Fields...> {
125 | private:
126 |   crust_static_assert(All<Not<IsConstOrRefVal<Fields>>...>::result);
127 | 
128 |   template <usize index>
129 |   using Getter = _impl_tuple::TupleGetter<index, Fields...>;
130 | 
131 | protected:
132 |   CRUST_USE_BASE_CONSTRUCTORS(
133 |       TupleStruct, _impl_tuple::TupleSizedHolder<Fields...>);
134 | 
135 | public:
136 |   template <usize index>
137 |   constexpr const typename Getter<index>::Result &get() const {
138 |     return Getter<index>::inner(*this);
139 |   }
140 | 
141 |   template <usize index>
142 |   crust_cxx14_constexpr typename Getter<index>::Result &get() {
143 |     return Getter<index>::inner(*this);
144 |   }
145 | };
146 | 
147 | template <>
148 | struct TupleStruct<> {
149 | protected:
150 |   constexpr TupleStruct() {}
151 | };
152 | 
153 | namespace _impl_derive {
154 | template <class... Fields>
155 | struct TupleLikeSize<TupleStruct<Fields...>> :
156 |     TmplVal<usize, sizeof...(Fields)> {};
157 | 
158 | template <usize index, class... Fields>
159 | struct TupleLikeGetter<TupleStruct<Fields...>, index> {
160 |   using Result = typename _impl_types::
161 |       TypesIndex<index, _impl_types::Types<Fields...>>::Result;
162 | 
163 |   static constexpr const Result &get(const TupleStruct<Fields...> &self) {
164 |     return self.template get<index>();
165 |   }
166 | 
167 |   static constexpr Result &get(TupleStruct<Fields...> &self) {
168 |     return self.template get<index>();
169 |   }
170 | };
171 | 
172 | template <usize... indexs>
173 | struct IndexSequence {};
174 | 
175 | template <usize size, usize... indexs>
176 | struct IndexSequenceImpl : IndexSequenceImpl<size - 1, size - 1, indexs...> {};
177 | 
178 | template <usize... indexs>
179 | struct IndexSequenceImpl<0, indexs...> : TmplType<IndexSequence<indexs...>> {};
180 | 
181 | template <usize size>
182 | using MakeIndexSequence = typename IndexSequenceImpl<size>::Result;
183 | 
184 | template <class Self, class Index>
185 | struct TupleLikeCloneHelper;
186 | 
187 | template <class Self, usize... indexs>
188 | struct TupleLikeCloneHelper<Self, IndexSequence<indexs...>> {
189 |   static constexpr Self clone(const Self &self) {
190 |     return Self{clone::clone(self.template get<indexs>())...};
191 |   }
192 | };
193 | 
194 | template <class T, template <class, class...> class Trait, class... Args>
195 | struct ImplForTupleStructHelper : TmplVal<bool, false> {};
196 | 
197 | template <
198 |     class... Fields,
199 |     template <class, class...>
200 |     class Trait,
201 |     class... Args>
202 | struct ImplForTupleStructHelper<TupleStruct<Fields...>, Trait, Args...> :
203 |     All<Require<Fields, Trait, Args...>...> {};
204 | 
205 | template <class T, template <class, class...> class Trait, class... Args>
206 | using ImplForTupleStruct =
207 |     ImplForTupleStructHelper<typename BluePrint<T>::Result, Trait, Args...>;
208 | } // namespace _impl_derive
209 | 
210 | template <class S>
211 | CRUST_IMPL_FOR(
212 |     ZeroSizedType<S>, _impl_derive::ImplForTupleStruct<S, ZeroSizedType>){};
213 | 
214 | template <class S>
215 | CRUST_IMPL_FOR(
216 |     clone::Clone<S>, _impl_derive::ImplForTupleStruct<S, clone::Clone>) {
217 |   CRUST_IMPL_USE_SELF(S);
218 | 
219 | private:
220 |   using CloneHelper = _impl_derive::TupleLikeCloneHelper<
221 |       Self,
222 |       _impl_derive::MakeIndexSequence<
223 |           _impl_derive::TupleLikeSize<typename BluePrint<S>::Result>::result>>;
224 | 
225 | public:
226 |   Self clone() const { return CloneHelper::clone(self()); }
227 | };
228 | 
229 | template <class S>
230 | CRUST_IMPL_FOR(
231 |     cmp::PartialEq<S>, _impl_derive::ImplForTupleStruct<S, cmp::PartialEq>) {
232 |   CRUST_IMPL_USE_SELF(S);
233 | 
234 | private:
235 |   using PartialEqHelper = _impl_derive::
236 |       TupleLikePartialEqHelper<Self, typename BluePrint<S>::Result>;
237 | 
238 | public:
239 |   constexpr bool eq(const Self &other) const {
240 |     return PartialEqHelper::eq(self(), other);
241 |   }
242 | 
243 |   constexpr bool ne(const Self &other) const {
244 |     return PartialEqHelper::ne(self(), other);
245 |   }
246 | };
247 | 
248 | template <class S>
249 | CRUST_IMPL_FOR(cmp::Eq<S>, _impl_derive::ImplForTupleStruct<S, cmp::Eq>){};
250 | 
251 | template <class S>
252 | CRUST_IMPL_FOR(
253 |     cmp::PartialOrd<S>, _impl_derive::ImplForTupleStruct<S, cmp::PartialOrd>) {
254 |   CRUST_IMPL_USE_SELF(S);
255 | 
256 | private:
257 |   using PartialOrdHelper = _impl_derive::
258 |       TupleLikePartialOrdHelper<Self, typename BluePrint<S>::Result>;
259 | 
260 | public:
261 |   constexpr Option<cmp::Ordering> partial_cmp(const Self &other) const;
262 | 
263 |   constexpr bool lt(const Self &other) const {
264 |     return PartialOrdHelper::lt(self(), other);
265 |   }
266 | 
267 |   constexpr bool le(const Self &other) const {
268 |     return PartialOrdHelper::le(self(), other);
269 |   }
270 | 
271 |   constexpr bool gt(const Self &other) const {
272 |     return PartialOrdHelper::gt(self(), other);
273 |   }
274 | 
275 |   constexpr bool ge(const Self &other) const {
276 |     return PartialOrdHelper::ge(self(), other);
277 |   }
278 | };
279 | 
280 | template <class S>
281 | CRUST_IMPL_FOR(cmp::Ord<S>, _impl_derive::ImplForTupleStruct<S, cmp::Ord>) {
282 |   CRUST_IMPL_USE_SELF(S);
283 | 
284 | private:
285 |   using OrdHelper =
286 |       _impl_derive::TupleLikeOrdHelper<Self, typename BluePrint<S>::Result>;
287 | 
288 | public:
289 |   constexpr cmp::Ordering cmp(const Self &other) const;
290 | };
291 | 
292 | template <class... Fields>
293 | struct crust_ebco Tuple :
294 |     TupleStruct<Fields...>,
295 |     Derive<
296 |         Tuple<Fields...>,
297 |         Trait<ZeroSizedType>,
298 |         Trait<clone::Clone>,
299 |         Trait<cmp::PartialEq>,
300 |         Trait<cmp::Eq>,
301 |         Trait<cmp::PartialOrd>,
302 |         Trait<cmp::Ord>> {
303 |   CRUST_USE_BASE_CONSTRUCTORS(Tuple, TupleStruct<Fields...>);
304 | };
305 | 
306 | template <class... Fields>
307 | struct BluePrint<Tuple<Fields...>> : TmplType<TupleStruct<Fields...>> {};
308 | 
309 | template <class... Fields, class U>
310 | struct ZeroSizedTypeConvertible<Tuple<Fields...>, U> :
311 |     Any<_impl_types::TypesIncludeVal<U, _impl_types::Types<Fields...>>,
312 |         _impl_types::TypesContainVal<U, _impl_types::Types<Fields...>>> {};
313 | 
314 | namespace _impl_tuple {
315 | template <class T, class U, bool is_contain>
316 | struct ZeroSizedTypeConvertHelper;
317 | 
318 | template <class... Fields, class U>
319 | struct ZeroSizedTypeConvertHelper<Tuple<Fields...>, U, true> {
320 |   static constexpr usize index =
321 |       _impl_types::TypesFirstContain<U, _impl_types::Types<Fields...>>::result;
322 |   using Convert = ZeroSizedTypeConvert<
323 |       typename _impl_types::TypesIndex<index, _impl_types::Types<Fields...>>::
324 |           Result,
325 |       U>;
326 | 
327 |   static constexpr const U &inner(const Tuple<Fields...> &self) {
328 |     return Convert::inner(self.template get<index>());
329 |   }
330 | 
331 |   static constexpr U &inner(Tuple<Fields...> &self) {
332 |     return Convert::inner(self.template get<index>());
333 |   }
334 | };
335 | 
336 | template <class... Fields, class U>
337 | struct ZeroSizedTypeConvertHelper<Tuple<Fields...>, U, false> {
338 |   static constexpr usize index =
339 |       _impl_types::TypesFirstIndex<U, _impl_types::Types<Fields...>>::result;
340 | 
341 |   static constexpr const U &inner(const Tuple<Fields...> &self) {
342 |     return self.template get<index>();
343 |   }
344 | 
345 |   static constexpr U &inner(Tuple<Fields...> &self) {
346 |     return self.template get<index>();
347 |   }
348 | };
349 | } // namespace _impl_tuple
350 | 
351 | template <class... Fields, class U>
352 | struct ZeroSizedTypeConvert<Tuple<Fields...>, U> :
353 |     _impl_tuple::ZeroSizedTypeConvertHelper<
354 |         Tuple<Fields...>,
355 |         U,
356 |         _impl_types::TypesContainVal<U, _impl_types::Types<Fields...>>::
357 |             result> {};
358 | } // namespace crust
359 | 
360 | 
361 | #endif // CRUST_TUPLE_DECL_HPP
362 | 


--------------------------------------------------------------------------------
/include/crust/utility.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef CRUST_UTILITY_HPP
  2 | #define CRUST_UTILITY_HPP
  3 | 
  4 | 
  5 | #include <cstdint>
  6 | #include <cstdio>
  7 | #include <cstdlib>
  8 | #include <type_traits>
  9 | 
 10 | 
 11 | namespace crust {
 12 | #if __cplusplus > 201103L
 13 | #define crust_cxx14_constexpr constexpr
 14 | #else
 15 | #define crust_cxx14_constexpr
 16 | #endif
 17 | 
 18 | #if __cplusplus > 201402L
 19 | #define crust_cxx17_constexpr constexpr
 20 | #else
 21 | #define crust_cxx17_constexpr
 22 | #endif
 23 | 
 24 | #if __cplusplus > 201402L
 25 | #define crust_static_assert(...) static_assert(__VA_ARGS__)
 26 | #else
 27 | #define crust_static_assert(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
 28 | #endif
 29 | 
 30 | #if defined(_MSC_VER)
 31 | #define crust_ebco __declspec(empty_bases)
 32 | #else
 33 | #define crust_ebco
 34 | #endif
 35 | 
 36 | #if defined(__GNUC__) || defined(__clang__)
 37 | #define crust_no_return __attribute__((noreturn))
 38 | #elif defined(_MSC_VER)
 39 | #define crust_no_return __declspec(noreturn)
 40 | #else
 41 | #define crust_no_return
 42 | #endif
 43 | 
 44 | #if defined(__GNUC__) || defined(__clang__)
 45 | #define crust_likely(x) __builtin_expect(!!(x), 1)
 46 | #define crust_unlikely(x) __builtin_expect(!!(x), 0)
 47 | #else
 48 | #define crust_likely(x) x
 49 | #define crust_unlikely(x) x
 50 | #endif
 51 | 
 52 | #if defined(__GNUC__) || defined(__clang__)
 53 | #define crust_always_inline inline __attribute__((always_inline))
 54 | #elif defined(_MSC_VER)
 55 | #define crust_always_inline __forceinline
 56 | #else
 57 | #define crust_always_inline inline
 58 | #endif
 59 | 
 60 | namespace _impl_utility {
 61 | crust_no_return inline void
 62 | panic(const char *file, int line, const char *msg) noexcept {
 63 |   fprintf(stderr, "Panic at file %s, line %d: %s\n", file, line, msg);
 64 |   exit(1);
 65 | }
 66 | 
 67 | #define crust_panic(msg) _impl_utility::panic(__FILE__, __LINE__, msg)
 68 | 
 69 | #define crust_assert(expr)                                                     \
 70 |   (crust_likely(expr) ? void(0) : [](const char *f, int l, const char *m) {    \
 71 |     fprintf(stderr, "Assert failed at file %s, line %d: %s\n", f, l, m);       \
 72 |     exit(-1);                                                                  \
 73 |   }(__FILE__, __LINE__, #expr))
 74 | 
 75 | #if defined(NODEBUG)
 76 | #define crust_debug_assert(expr)
 77 | #else
 78 | #define crust_debug_assert(expr) crust_assert(expr)
 79 | #endif
 80 | 
 81 | #if defined(NODEBUG)
 82 | #if defined(__GNUC__) || defined(__clang__)
 83 | #define crust_unreachable() __builtin_unreachable()
 84 | #elif defined(_MSC_VER)
 85 | #define crust_unreachable() __assume(false)
 86 | #else
 87 | #define crust_unreachable()
 88 | #endif
 89 | #else
 90 | #define crust_unreachable() crust_panic("should not reach here!")
 91 | #endif
 92 | } // namespace _impl_utility
 93 | 
 94 | #define CRUST_MACRO(...) __VA_ARGS__
 95 | 
 96 | using i8 = int8_t;
 97 | using u8 = uint8_t;
 98 | using i16 = int16_t;
 99 | using u16 = uint16_t;
100 | using i32 = int32_t;
101 | using u32 = uint32_t;
102 | using i64 = int64_t;
103 | using u64 = uint64_t;
104 | #if INTPTR_MAX == INT32_MAX
105 | using isize = i32;
106 | using usize = u32;
107 | #elif INTPTR_MAX == INT64_MAX
108 | using isize = i64;
109 | using usize = u64;
110 | #else
111 | #error "Unsupported bit width."
112 | #endif
113 | 
114 | template <class Value>
115 | struct TmplType {
116 |   using Result = Value;
117 | };
118 | 
119 | template <class Type, Type value>
120 | struct TmplVal : TmplType<Type> {
121 |   static constexpr Type result = value;
122 | };
123 | 
124 | #define crust_tmpl_val(obj)                                                    \
125 |   ::crust::TmplVal<decltype(obj), (obj)> {}
126 | 
127 | template <bool value>
128 | struct BoolVal : TmplVal<bool, value> {};
129 | 
130 | template <class Bool>
131 | struct Not : BoolVal<!Bool::result> {};
132 | 
133 | template <class... Bools>
134 | struct All;
135 | 
136 | template <class Bool, class... Bools>
137 | struct All<Bool, Bools...> : BoolVal<Bool::result && All<Bools...>::result> {};
138 | 
139 | template <>
140 | struct All<> : BoolVal<true> {};
141 | 
142 | template <class... Bools>
143 | struct Any;
144 | 
145 | template <class Bool, class... Bools>
146 | struct Any<Bool, Bools...> : BoolVal<Bool::result || Any<Bools...>::result> {};
147 | 
148 | template <>
149 | struct Any<> : BoolVal<false> {};
150 | 
151 | namespace _impl_utility {
152 | template <bool condition, class A, class B>
153 | struct IfElse;
154 | 
155 | template <class A, class B>
156 | struct IfElse<true, A, B> : A {};
157 | 
158 | template <class A, class B>
159 | struct IfElse<false, A, B> : B {};
160 | } // namespace _impl_utility
161 | 
162 | template <class C, class A, class B>
163 | using IfElse = _impl_utility::IfElse<C::result, A, B>;
164 | 
165 | template <class U, class A>
166 | struct AsVal : TmplVal<U, A::result> {};
167 | 
168 | template <class T, template <class> class... Tmpls>
169 | struct CompositionType;
170 | 
171 | template <class T, template <class> class Tmpl, template <class> class... Tmpls>
172 | struct CompositionType<T, Tmpl, Tmpls...> :
173 |     CompositionType<typename Tmpl<T>::Result, Tmpls...> {};
174 | 
175 | template <class T>
176 | struct CompositionType<T> : TmplType<T> {};
177 | 
178 | template <class A, class B>
179 | struct IsSame : BoolVal<false> {};
180 | 
181 | template <class A>
182 | struct IsSame<A, A> : BoolVal<true> {};
183 | 
184 | template <class T>
185 | struct RemoveRefType : TmplType<T> {};
186 | 
187 | template <class T>
188 | struct RemoveRefType<T &> : TmplType<T> {};
189 | 
190 | template <class T>
191 | struct RemoveRefType<T &&> : TmplType<T> {};
192 | 
193 | template <class T>
194 | struct RemoveConstType : TmplType<T> {};
195 | 
196 | template <class T>
197 | struct RemoveConstType<T const> : TmplType<T> {};
198 | 
199 | template <class T>
200 | struct RemoveConstOrRefType :
201 |     CompositionType<T, RemoveRefType, RemoveConstType> {};
202 | 
203 | template <class T>
204 | struct IsEmptyType : BoolVal<std::is_empty<T>::value> {};
205 | 
206 | template <class T>
207 | struct IsLValueRefVal : BoolVal<false> {};
208 | 
209 | template <class T>
210 | struct IsLValueRefVal<T &> : BoolVal<true> {};
211 | 
212 | template <class T>
213 | struct IsRValueRefVal : BoolVal<false> {};
214 | 
215 | template <class T>
216 | struct IsRValueRefVal<T &&> : BoolVal<true> {};
217 | 
218 | template <class T>
219 | struct IsConstVal : BoolVal<false> {};
220 | 
221 | template <class T>
222 | struct IsConstVal<const T> : BoolVal<true> {};
223 | 
224 | template <class T>
225 | struct IsRefVal : Any<IsLValueRefVal<T>, IsRValueRefVal<T>> {};
226 | 
227 | template <class T>
228 | struct IsConstOrRefVal : Any<IsRefVal<T>, IsConstVal<T>> {};
229 | 
230 | template <class B, class T>
231 | struct IsBaseOfVal :
232 |     All<BoolVal<std::is_base_of<B, T>::value>, Not<IsSame<B, T>>> {};
233 | 
234 | template <class T>
235 | struct IsTriviallyCopyable : BoolVal<std::is_trivially_copyable<T>::value> {};
236 | 
237 | template <class T>
238 | constexpr typename RemoveRefType<T>::Result &&move(T &&t) {
239 |   return static_cast<typename RemoveRefType<T>::Result &&>(t);
240 | }
241 | 
242 | template <class T>
243 | constexpr T &&forward(typename RemoveRefType<T>::Result &t) {
244 |   return static_cast<T &&>(t);
245 | }
246 | 
247 | template <class T>
248 | constexpr T &&forward(typename RemoveRefType<T>::Result &&t) {
249 |   crust_static_assert(!IsLValueRefVal<T>::result);
250 |   return static_cast<T &&>(t);
251 | }
252 | 
253 | #define CRUST_USE_BASE_CONSTRUCTORS(NAME, ...)                                 \
254 |   template <class... Args>                                                     \
255 |   explicit constexpr NAME(Args &&...args) :                                    \
256 |       __VA_ARGS__{::crust::forward<Args>(args)...} {}
257 | 
258 | #define CRUST_TRAIT(TRAIT, ...)                                                \
259 |   template <class Self, ##__VA_ARGS__>                                         \
260 |   struct TRAIT
261 | 
262 | #define CRUST_TRAIT_USE_SELF(TRAIT, ...)                                       \
263 | private:                                                                       \
264 |   template <class Trait = TRAIT>                                               \
265 |   constexpr const ::crust::ImplFor<Trait> &self() const {                      \
266 |     return *static_cast<const ::crust::ImplFor<Trait> *>(                      \
267 |         static_cast<const Self *>(this));                                      \
268 |   }                                                                            \
269 |   template <class Trait = TRAIT>                                               \
270 |   crust_cxx14_constexpr ::crust::ImplFor<Trait> &self() {                      \
271 |     return *static_cast<::crust::ImplFor<Trait> *>(static_cast<Self *>(this)); \
272 |   }                                                                            \
273 |                                                                                \
274 | protected:                                                                     \
275 |   constexpr TRAIT() {                                                          \
276 |     crust_static_assert(!::crust::IsConstOrRefVal<Self>::result);              \
277 |     crust_static_assert(::crust::IsBaseOfVal<TRAIT, Self>::result);            \
278 |     crust_static_assert(::crust::All<__VA_ARGS__>::result);                    \
279 |   }                                                                            \
280 |                                                                                \
281 | public:
282 | 
283 | template <template <class, class...> class T, class... Args>
284 | struct Trait {};
285 | 
286 | template <class Trait, class Enable = void>
287 | struct ImplFor {};
288 | 
289 | #define CRUST_IMPL_FOR(TRAIT, ...)                                             \
290 |   struct ImplFor<TRAIT, EnableIf<__VA_ARGS__>> : TRAIT
291 | 
292 | #define CRUST_IMPL_USE_SELF(...)                                               \
293 | private:                                                                       \
294 |   using Self = __VA_ARGS__;                                                    \
295 |   constexpr const Self &self() const {                                         \
296 |     return *static_cast<const Self *>(this);                                   \
297 |   }                                                                            \
298 |   crust_cxx14_constexpr Self &self() { return *static_cast<Self *>(this); }    \
299 |                                                                                \
300 | protected:                                                                     \
301 |   constexpr ImplFor() {                                                        \
302 |     crust_static_assert(::crust::IsBaseOfVal<ImplFor, Self>::result);          \
303 |   }                                                                            \
304 |                                                                                \
305 | public:
306 | 
307 | template <class Self, class... Traits>
308 | struct crust_ebco Impl;
309 | 
310 | template <
311 |     class Self,
312 |     template <class, class...>
313 |     class T,
314 |     class... Args,
315 |     class... Traits>
316 | struct Impl<Self, Trait<T, Args...>, Traits...> :
317 |     ImplFor<T<Self, Args...>>,
318 |     Impl<Self, Traits...> {};
319 | 
320 | template <class Self>
321 | struct Impl<Self> {};
322 | 
323 | namespace _impl_derive {
324 | template <class Self>
325 | struct TupleLikeSize;
326 | 
327 | template <class Self, usize index>
328 | struct TupleLikeGetter;
329 | } // namespace _impl_derive
330 | 
331 | template <class Self>
332 | struct BluePrint;
333 | 
334 | template <class Self, class... Ts>
335 | struct crust_ebco Derive;
336 | 
337 | template <
338 |     class Self,
339 |     template <class, class...>
340 |     class T,
341 |     class... Args,
342 |     class... Traits>
343 | struct Derive<Self, Trait<T, Args...>, Traits...> :
344 |     ImplFor<T<Self, Args...>>,
345 |     Derive<Self, Traits...> {};
346 | 
347 | template <class Self>
348 | struct Derive<Self> {};
349 | 
350 | template <class Struct, template <class, class...> class Trait, class... Args>
351 | struct Require : IsBaseOfVal<Trait<Struct, Args...>, Struct> {};
352 | 
353 | namespace _impl_utility {
354 | template <bool enable>
355 | struct EnableIf {};
356 | 
357 | template <>
358 | struct EnableIf<true> : TmplType<void> {};
359 | 
360 | template <class T, bool Bool, class>
361 | struct InheritIf;
362 | 
363 | template <class T, class Marker>
364 | struct InheritIf<T, true, Marker> : T {
365 |   CRUST_USE_BASE_CONSTRUCTORS(InheritIf, T);
366 | };
367 | 
368 | template <class T, class Marker>
369 | struct InheritIf<T, false, Marker> {
370 |   constexpr InheritIf() {}
371 | 
372 |   constexpr InheritIf(T &&) {}
373 | };
374 | } // namespace _impl_utility
375 | 
376 | template <class... Enable>
377 | using EnableIf =
378 |     typename _impl_utility::EnableIf<All<Enable...>::result>::Result;
379 | 
380 | template <class T, class Bools, class Marker = void>
381 | using InheritIf = _impl_utility::InheritIf<T, Bools::result, Marker>;
382 | 
383 | /// this is used by Tuple, Enum and Slice for zero sized type optimization
384 | /// foreign type can implement ZeroSizedType to be treated as zero sized type.
385 | 
386 | CRUST_TRAIT(ZeroSizedType) {
387 |   CRUST_TRAIT_USE_SELF(
388 |       ZeroSizedType, IsEmptyType<Self>, IsTriviallyCopyable<Self>);
389 | };
390 | 
391 | template <class T, class U>
392 | struct ZeroSizedTypeConvertible : BoolVal<false> {};
393 | 
394 | template <class T, class U>
395 | struct ZeroSizedTypeConvert;
396 | 
397 | template <class T>
398 | struct RefMut {
399 | private:
400 |   T *ptr;
401 | 
402 | public:
403 |   constexpr RefMut() : ptr{nullptr} {}
404 | 
405 |   explicit constexpr RefMut(T &ptr) : ptr{&ptr} {}
406 | 
407 |   RefMut(const RefMut &other) = default;
408 | 
409 |   RefMut &operator=(const RefMut &other) = default;
410 | 
411 |   crust_cxx14_constexpr T &operator*() {
412 |     return crust_debug_assert(ptr != nullptr), *ptr;
413 |   }
414 | 
415 |   crust_cxx14_constexpr T *operator->() {
416 |     return crust_debug_assert(ptr != nullptr), ptr;
417 |   }
418 | };
419 | 
420 | template <class T>
421 | struct Ref {
422 | private:
423 |   const T *ptr;
424 | 
425 | public:
426 |   constexpr Ref() : ptr{nullptr} {}
427 | 
428 |   explicit constexpr Ref(const T &ptr) : ptr{&ptr} {}
429 | 
430 |   constexpr Ref(RefMut<T> &&ptr) : ptr{&*ptr} {}
431 | 
432 |   Ref(const Ref &other) = default;
433 | 
434 |   Ref &operator=(const Ref &other) = default;
435 | 
436 |   constexpr const T &operator*() const {
437 |     return crust_debug_assert(ptr != nullptr), *ptr;
438 |   }
439 | 
440 |   constexpr const T *operator->() const {
441 |     return crust_debug_assert(ptr != nullptr), ptr;
442 |   }
443 | };
444 | 
445 | template <class T>
446 | constexpr Ref<T> ref(const T &self) {
447 |   return Ref<T>{self};
448 | }
449 | 
450 | 
451 | template <class T>
452 | constexpr RefMut<T> ref_mut(T &self) {
453 |   return RefMut<T>{self};
454 | }
455 | 
456 | namespace _impl_utility {
457 | class Ignore {};
458 | 
459 | class IgnoreRange {};
460 | 
461 | class Argument {};
462 | } // namespace _impl_utility
463 | 
464 | constexpr _impl_utility::Ignore _{};
465 | 
466 | constexpr _impl_utility::IgnoreRange __{};
467 | 
468 | constexpr _impl_utility::Argument arg{};
469 | } // namespace crust
470 | 
471 | 
472 | #endif // CRUST_UTILITY_HPP
473 | 


--------------------------------------------------------------------------------
/include/crust/enum_decl.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef CRUST_ENUM_DECL_HPP
  2 | #define CRUST_ENUM_DECL_HPP
  3 | 
  4 | 
  5 | #include <new>
  6 | 
  7 | #include "crust/clone.hpp"
  8 | #include "crust/cmp_decl.hpp"
  9 | #include "crust/helper/repeat_macro.hpp"
 10 | #include "crust/helper/types.hpp"
 11 | #include "crust/num/mod.hpp"
 12 | #include "crust/tuple_decl.hpp"
 13 | #include "crust/utility.hpp"
 14 | 
 15 | 
 16 | namespace crust {
 17 | namespace _impl_enum {
 18 | #define CRUST_ENUM_VARIANT(NAME)                                               \
 19 |   struct crust_ebco NAME :                                                     \
 20 |       ::crust::TupleStruct<>,                                                  \
 21 |       ::crust::Derive<                                                         \
 22 |           NAME,                                                                \
 23 |           ::crust::Trait<::crust::ZeroSizedType>,                              \
 24 |           ::crust::Trait<::crust::clone::Clone>,                               \
 25 |           ::crust::Trait<::crust::cmp::PartialEq>,                             \
 26 |           ::crust::Trait<::crust::cmp::Eq>,                                    \
 27 |           ::crust::Trait<::crust::cmp::PartialOrd>,                            \
 28 |           ::crust::Trait<::crust::cmp::Ord>> {                                 \
 29 |     CRUST_USE_BASE_CONSTRUCTORS(NAME, ::crust::TupleStruct<>);                 \
 30 |   }
 31 | 
 32 | CRUST_TRAIT(DiscriminantVariant) { CRUST_TRAIT_USE_SELF(DiscriminantVariant); };
 33 | 
 34 | #define CRUST_DISCRIMINANT_VARIANT(NAME, VALUE)                                \
 35 |   struct crust_ebco NAME :                                                     \
 36 |       ::crust::TupleStruct<>,                                                  \
 37 |       ::crust::_impl_enum::DiscriminantVariant<NAME>,                          \
 38 |       ::crust::Derive<                                                         \
 39 |           NAME,                                                                \
 40 |           ::crust::Trait<::crust::ZeroSizedType>,                              \
 41 |           ::crust::Trait<::crust::clone::Clone>,                               \
 42 |           ::crust::Trait<::crust::cmp::PartialEq>,                             \
 43 |           ::crust::Trait<::crust::cmp::Eq>,                                    \
 44 |           ::crust::Trait<::crust::cmp::PartialOrd>,                            \
 45 |           ::crust::Trait<::crust::cmp::Ord>> {                                 \
 46 |     static constexpr ::crust::isize result = VALUE;                            \
 47 |     CRUST_USE_BASE_CONSTRUCTORS(NAME, ::crust::TupleStruct<>);                 \
 48 |   }
 49 | 
 50 | template <class I, bool is_spec, class T, class... Fields>
 51 | struct DiscriminantImpl;
 52 | 
 53 | template <class I, class T, class... Fields>
 54 | using Discriminant =
 55 |     DiscriminantImpl<I, Require<T, DiscriminantVariant>::result, T, Fields...>;
 56 | 
 57 | template <class I, class T, class... Fields>
 58 | struct DiscriminantImpl<I, false, T, Fields...> :
 59 |     IncVal<Discriminant<
 60 |         I,
 61 |         typename _impl_types::TypesPrevType<T, Fields...>::Result,
 62 |         Fields...>> {};
 63 | 
 64 | template <class I, class T, class... Fields>
 65 | struct DiscriminantImpl<I, false, T, T, Fields...> : TmplVal<I, 0> {};
 66 | // FIXME: use the real type
 67 | template <class I, class T, class... Fields>
 68 | struct DiscriminantImpl<I, true, T, Fields...> :
 69 |     TmplVal<I, static_cast<I>(T::result)> {
 70 |   crust_static_assert(T::result <= static_cast<isize>(num::Int<I>::MAX));
 71 |   crust_static_assert(T::result >= static_cast<isize>(num::Int<I>::MIN));
 72 | };
 73 | 
 74 | template <class I, isize index, class... Fields>
 75 | struct IndexToDiscriminant :
 76 |     Discriminant<
 77 |         I,
 78 |         typename _impl_types::TypesIndex<index, _impl_types::Types<Fields...>>::
 79 |             Result,
 80 |         Fields...> {};
 81 | 
 82 | template <class I, isize index, class... Fields>
 83 | struct CheckDiscriminant :
 84 |     All<LTVal<
 85 |             IndexToDiscriminant<I, index - 1, Fields...>,
 86 |             IndexToDiscriminant<I, index, Fields...>>,
 87 |         CheckDiscriminant<I, index - 1, Fields...>> {};
 88 | 
 89 | template <class I, class... Fields>
 90 | struct CheckDiscriminant<I, 0, Fields...> : BoolVal<true> {};
 91 | 
 92 | #define CRUST_ENUM_TUPLE_VARIANT(NAME, FULL_NAME, ...)                         \
 93 |   struct crust_ebco NAME :                                                     \
 94 |       ::crust::TupleStruct<__VA_ARGS__>,                                       \
 95 |       ::crust::Derive<                                                         \
 96 |           FULL_NAME,                                                           \
 97 |           ::crust::Trait<::crust::ZeroSizedType>,                              \
 98 |           ::crust::Trait<::crust::clone::Clone>,                               \
 99 |           ::crust::Trait<::crust::cmp::PartialEq>,                             \
100 |           ::crust::Trait<::crust::cmp::Eq>,                                    \
101 |           ::crust::Trait<::crust::cmp::PartialOrd>,                            \
102 |           ::crust::Trait<::crust::cmp::Ord>> {                                 \
103 |     CRUST_USE_BASE_CONSTRUCTORS(NAME, ::crust::TupleStruct<__VA_ARGS__>);      \
104 |   }
105 | 
106 | #define CRUST_ENUM_USE_BASE(NAME, ...)                                         \
107 |   template <class... Args>                                                     \
108 |   constexpr NAME(Args &&...args) :                                             \
109 |       __VA_ARGS__{::crust::forward<Args>(args)...} {}
110 | 
111 | template <bool trivial, class... Fields>
112 | union EnumHolderImpl;
113 | 
114 | template <class Field, class... Fields>
115 | union EnumHolderImpl<true, Field, Fields...> {
116 |   Field field;
117 |   EnumHolderImpl<true, Fields...> remains;
118 | 
119 |   constexpr EnumHolderImpl() : remains{} {}
120 | 
121 |   explicit constexpr EnumHolderImpl(Field &&field) : field{move(field)} {}
122 | 
123 |   explicit constexpr EnumHolderImpl(const Field &field) : field{field} {}
124 | 
125 |   template <class T>
126 |   explicit constexpr EnumHolderImpl(T &&field) : remains{forward<T>(field)} {}
127 | };
128 | 
129 | template <class Field, class... Fields>
130 | union EnumHolderImpl<false, Field, Fields...> {
131 |   Field field;
132 |   EnumHolderImpl<false, Fields...> remains;
133 | 
134 |   constexpr EnumHolderImpl() : remains{} {}
135 | 
136 |   explicit constexpr EnumHolderImpl(Field &&field) : field{move(field)} {}
137 | 
138 |   explicit constexpr EnumHolderImpl(const Field &field) : field{field} {}
139 | 
140 |   template <class T>
141 |   explicit constexpr EnumHolderImpl(T &&field) : remains{forward<T>(field)} {}
142 | 
143 |   EnumHolderImpl(const EnumHolderImpl &) {}
144 | 
145 |   EnumHolderImpl(EnumHolderImpl &&) noexcept {}
146 | 
147 |   EnumHolderImpl &operator=(const EnumHolderImpl &) { return *this; }
148 | 
149 |   EnumHolderImpl &operator=(EnumHolderImpl &&) noexcept { return *this; }
150 | 
151 |   ~EnumHolderImpl() {}
152 | };
153 | 
154 | template <bool trivial>
155 | union EnumHolderImpl<trivial> {};
156 | 
157 | template <class... Fields>
158 | using EnumHolder =
159 |     EnumHolderImpl<All<IsTriviallyCopyable<Fields>...>::result, Fields...>;
160 | 
161 | template <isize index, class... Fields>
162 | struct EnumGetter;
163 | 
164 | template <isize index, class Field, class... Fields>
165 | struct EnumGetter<index, Field, Fields...> {
166 |   using Self = EnumHolder<Field, Fields...>;
167 |   using Result = typename _impl_types::
168 |       TypesIndex<index, _impl_types::Types<Field, Fields...>>::Result;
169 | 
170 |   static constexpr const Result &inner(const Self &self) {
171 |     return EnumGetter<index - 1, Fields...>::inner(self.remains);
172 |   }
173 | 
174 |   static constexpr Result &inner(Self &self) {
175 |     return EnumGetter<index - 1, Fields...>::inner(self.remains);
176 |   }
177 | };
178 | 
179 | template <class Field, class... Fields>
180 | struct EnumGetter<0, Field, Fields...> {
181 |   using Self = EnumHolder<Field, Fields...>;
182 |   using Result = Field;
183 | 
184 |   static constexpr const Result &inner(const Self &self) { return self.field; }
185 | 
186 |   static constexpr Result &inner(Self &self) { return self.field; }
187 | };
188 | 
189 | template <class Self, isize offset, isize size, class... Fields>
190 | struct EnumVisitor {
191 |   static constexpr isize cut = size / 2;
192 | 
193 |   using LowerGetter = EnumVisitor<Self, offset, cut, Fields...>;
194 |   using UpperGetter = EnumVisitor<Self, offset + cut, size - cut, Fields...>;
195 |   static constexpr typename Self::Index discriminant =
196 |       IndexToDiscriminant<typename Self::Index, offset + cut, Fields...>::
197 |           result;
198 | 
199 |   template <class R, class V>
200 |   static constexpr R inner(const Self &self, V &&impl) {
201 |     return self.get_index() < discriminant ?
202 |         LowerGetter::template inner<R, V>(self, forward<V>(impl)) :
203 |         UpperGetter::template inner<R, V>(self, forward<V>(impl));
204 |   }
205 | 
206 |   template <class R, class V>
207 |   static constexpr R inner(Self &self, V &&impl) {
208 |     return self.get_index() < discriminant ?
209 |         LowerGetter::template inner<R, V>(self, forward<V>(impl)) :
210 |         UpperGetter::template inner<R, V>(self, forward<V>(impl));
211 |   }
212 | };
213 | 
214 | #define _ENUM_VISITOR_BRANCH(index)                                            \
215 |   case GetIndex<index>::result:                                                \
216 |     return impl(self.template unsafe_get_variant<GetType<index>>());
217 | 
218 | #define _ENUM_VISITOR_SWITCH_IMPL(len)                                         \
219 |   template <class Self, isize offset, class... Fields>                         \
220 |   struct EnumVisitor<Self, offset, len, Fields...> {                           \
221 |     template <isize index>                                                     \
222 |     using GetIndex =                                                           \
223 |         IndexToDiscriminant<typename Self::Index, offset + index, Fields...>;  \
224 |     template <isize index>                                                     \
225 |     using GetType = typename _impl_types::                                     \
226 |         TypesIndex<offset + index, _impl_types::Types<Fields...>>::Result;     \
227 |     template <class R, class V>                                                \
228 |     static crust_cxx14_constexpr R inner(const Self &self, V &&impl) {         \
229 |       switch (self.get_index()) {                                              \
230 |         CRUST_MACRO_REPEAT(len, _ENUM_VISITOR_BRANCH);                         \
231 |       default:                                                                 \
232 |         crust_unreachable();                                                   \
233 |       }                                                                        \
234 |     }                                                                          \
235 |     template <class R, class V>                                                \
236 |     static crust_cxx14_constexpr R inner(Self &self, V &&impl) {               \
237 |       switch (self.get_index()) {                                              \
238 |         CRUST_MACRO_REPEAT(len, _ENUM_VISITOR_BRANCH);                         \
239 |       default:                                                                 \
240 |         crust_unreachable();                                                   \
241 |       }                                                                        \
242 |     }                                                                          \
243 |   }
244 | 
245 | _ENUM_VISITOR_SWITCH_IMPL(16);
246 | _ENUM_VISITOR_SWITCH_IMPL(15);
247 | _ENUM_VISITOR_SWITCH_IMPL(14);
248 | _ENUM_VISITOR_SWITCH_IMPL(13);
249 | _ENUM_VISITOR_SWITCH_IMPL(12);
250 | _ENUM_VISITOR_SWITCH_IMPL(11);
251 | _ENUM_VISITOR_SWITCH_IMPL(10);
252 | _ENUM_VISITOR_SWITCH_IMPL(9);
253 | _ENUM_VISITOR_SWITCH_IMPL(8);
254 | _ENUM_VISITOR_SWITCH_IMPL(7);
255 | _ENUM_VISITOR_SWITCH_IMPL(6);
256 | _ENUM_VISITOR_SWITCH_IMPL(5);
257 | _ENUM_VISITOR_SWITCH_IMPL(4);
258 | _ENUM_VISITOR_SWITCH_IMPL(3);
259 | _ENUM_VISITOR_SWITCH_IMPL(2);
260 | _ENUM_VISITOR_SWITCH_IMPL(1);
261 | 
262 | #undef _ENUM_VISITOR_SWITCH_IMPL
263 | #undef _ENUM_VISITOR_BRANCH
264 | 
265 | template <class Self, bool flag>
266 | struct EnumTrivial {};
267 | 
268 | template <class Self>
269 | struct EnumTrivial<Self, false> {
270 | private:
271 |   constexpr const Self &self() const {
272 |     return *static_cast<const Self *>(this);
273 |   }
274 | 
275 |   crust_cxx14_constexpr Self &self() { return *static_cast<Self *>(this); }
276 | 
277 |   struct Drop {
278 |     template <class T>
279 |     crust_cxx14_constexpr void operator()(T &value) const {
280 |       value.~T();
281 |     }
282 |   };
283 | 
284 |   struct MoveTo {
285 |     Self *other;
286 | 
287 |     template <class T>
288 |     void operator()(T &value) {
289 |       ::new (&other->template unsafe_get_variant<T>()) T{move(value)};
290 |     }
291 |   };
292 | 
293 |   struct CopyTo {
294 |     Self *other;
295 | 
296 |     template <class T>
297 |     void operator()(const T &value) {
298 |       ::new (&other->template unsafe_get_variant<T>()) T{value};
299 |     }
300 |   };
301 | 
302 |   void drop() {
303 |     if (self().index != 0) {
304 |       self().visit(Drop{});
305 |       self().index = 0;
306 |     }
307 |   }
308 | 
309 |   void move_from(Self &&other) { other.visit(MoveTo{&self()}); }
310 | 
311 |   void clone_from(const Self &other) { other.visit(CopyTo{&self()}); }
312 | 
313 | public:
314 |   constexpr EnumTrivial() {}
315 | 
316 |   EnumTrivial(const EnumTrivial &other) { clone_from(other.self()); }
317 | 
318 |   EnumTrivial(EnumTrivial &&other) noexcept { move_from(move(other.self())); }
319 | 
320 |   EnumTrivial &operator=(const EnumTrivial &other) {
321 |     if (this != &other) {
322 |       drop();
323 |       clone_from(other.self());
324 |     }
325 | 
326 |     return *this;
327 |   }
328 | 
329 |   EnumTrivial &operator=(EnumTrivial &&other) noexcept {
330 |     if (this != &other) {
331 |       drop();
332 |       move_from(move(other.self()));
333 |     }
334 | 
335 |     return *this;
336 |   }
337 | 
338 |   ~EnumTrivial() { drop(); }
339 | };
340 | 
341 | template <class Index_, class... Fields>
342 | struct crust_ebco EnumTagUnion :
343 |     EnumTrivial<
344 |         EnumTagUnion<Index_, Fields...>,
345 |         All<IsTriviallyCopyable<Fields>...>::result> {
346 |   using Index = Index_;
347 | 
348 |   using Getter = EnumVisitor<EnumTagUnion, 0, sizeof...(Fields), Fields...>;
349 | 
350 |   template <class T>
351 |   using IndexGetter =
352 |       Discriminant<Index, typename RemoveConstOrRefType<T>::Result, Fields...>;
353 | 
354 |   crust_static_assert(
355 |       All<Not<Require<Fields, DiscriminantVariant>>...>::result);
356 | 
357 |   struct Equal {
358 |     const EnumTagUnion *other;
359 | 
360 |     template <class T>
361 |     constexpr bool operator()(const T &value) const {
362 |       return value == other->unsafe_get_variant<T>();
363 |     };
364 |   };
365 | 
366 |   struct NotEqual {
367 |     const EnumTagUnion *other;
368 | 
369 |     template <class T>
370 |     constexpr bool operator()(const T &value) const {
371 |       return value != other->unsafe_get_variant<T>();
372 |     };
373 |   };
374 | 
375 |   struct PartialCmp {
376 |     const EnumTagUnion *other;
377 | 
378 |     template <class T>
379 |     constexpr Option<cmp::Ordering> operator()(const T &value) const;
380 |   };
381 | 
382 |   struct LessThan {
383 |     const EnumTagUnion *other;
384 | 
385 |     template <class T>
386 |     constexpr bool operator()(const T &value) const {
387 |       return value < other->unsafe_get_variant<T>();
388 |     };
389 |   };
390 | 
391 |   struct LessEqual {
392 |     const EnumTagUnion *other;
393 | 
394 |     template <class T>
395 |     constexpr bool operator()(const T &value) const {
396 |       return value <= other->unsafe_get_variant<T>();
397 |     };
398 |   };
399 | 
400 |   struct GreaterThan {
401 |     const EnumTagUnion *other;
402 | 
403 |     template <class T>
404 |     constexpr bool operator()(const T &value) const {
405 |       return value > other->unsafe_get_variant<T>();
406 |     };
407 |   };
408 | 
409 |   struct GreaterEqual {
410 |     const EnumTagUnion *other;
411 | 
412 |     template <class T>
413 |     constexpr bool operator()(const T &value) const {
414 |       return value >= other->unsafe_get_variant<T>();
415 |     };
416 |   };
417 | 
418 |   struct Cmp {
419 |     const EnumTagUnion *other;
420 | 
421 |     template <class T>
422 |     constexpr cmp::Ordering operator()(const T &value) const;
423 |   };
424 | 
425 |   Index index;
426 |   EnumHolder<Fields...> holder;
427 | 
428 |   constexpr EnumTagUnion() : index{0}, holder{} {}
429 | 
430 |   template <class T>
431 |   explicit constexpr EnumTagUnion(T &&value) :
432 |       index{IndexGetter<T>::result + 1}, holder{forward<T>(value)} {}
433 | 
434 |   template <class T>
435 |   EnumTagUnion &operator=(T &&value) {
436 |     ~EnumTagUnion();
437 | 
438 |     ::new (&holder) EnumHolder<Fields...>{forward<T>(value)};
439 |     set_index(IndexGetter<T>::result);
440 | 
441 |     return *this;
442 |   }
443 | 
444 |   constexpr Index get_index() const { return index - 1; }
445 | 
446 |   crust_cxx14_constexpr void set_index(Index index) { this->index = index + 1; }
447 | 
448 |   template <class T>
449 |   constexpr const T &unsafe_get_variant() const {
450 |     return EnumGetter<
451 |         _impl_types::TypesFirstIndex<T, _impl_types::Types<Fields...>>::result,
452 |         Fields...>::inner(holder);
453 |   }
454 | 
455 |   template <class T>
456 |   crust_cxx14_constexpr T &unsafe_get_variant() {
457 |     return EnumGetter<
458 |         _impl_types::TypesFirstIndex<T, _impl_types::Types<Fields...>>::result,
459 |         Fields...>::inner(holder);
460 |   }
461 | 
462 |   template <class T>
463 |   constexpr bool is_variant() const {
464 |     return get_index() == IndexGetter<T>::result;
465 |   }
466 | 
467 |   template <class R = void, class V>
468 |   constexpr R visit(V &&visitor) const {
469 |     return Getter::template inner<R, V>(*this, forward<V>(visitor));
470 |   }
471 | 
472 |   template <class R = void, class V>
473 |   crust_cxx14_constexpr R visit(V &&visitor) {
474 |     return Getter::template inner<R, V>(*this, forward<V>(visitor));
475 |   }
476 | 
477 |   constexpr bool eq(const EnumTagUnion &other) const {
478 |     return index == other.index && visit<bool>(Equal{&other});
479 |   }
480 | 
481 |   constexpr bool ne(const EnumTagUnion &other) const {
482 |     return index != other.index || visit<bool>(NotEqual{&other});
483 |   }
484 | 
485 |   constexpr Option<cmp::Ordering> partial_cmp(const EnumTagUnion &other) const;
486 | 
487 |   constexpr bool lt(const EnumTagUnion &other) const {
488 |     return index != other.index ? index < other.index :
489 |                                   visit<bool>(LessThan{&other});
490 |   }
491 | 
492 |   constexpr bool le(const EnumTagUnion &other) const {
493 |     return index != other.index ? index <= other.index :
494 |                                   visit<bool>(LessEqual{&other});
495 |   }
496 | 
497 |   constexpr bool gt(const EnumTagUnion &other) const {
498 |     return index != other.index ? index > other.index :
499 |                                   visit<bool>(GreaterThan{&other});
500 |   }
501 | 
502 |   constexpr bool ge(const EnumTagUnion &other) const {
503 |     return index != other.index ? index >= other.index :
504 |                                   visit<bool>(GreaterEqual{&other});
505 |   }
506 | 
507 |   constexpr cmp::Ordering cmp(const EnumTagUnion &other) const;
508 | };
509 | 
510 | template <class Index_, class... Fields>
511 | struct crust_ebco EnumTagOnly : _impl_types::ZeroSizedTypeHolder<Fields...> {
512 |   using Index = Index_;
513 | 
514 |   using Getter = EnumVisitor<EnumTagOnly, 0, sizeof...(Fields), Fields...>;
515 | 
516 |   template <class T>
517 |   using IndexGetter =
518 |       Discriminant<Index, typename RemoveConstOrRefType<T>::Result, Fields...>;
519 | 
520 |   crust_static_assert(
521 |       CheckDiscriminant<Index, sizeof...(Fields) - 1, Fields...>::result);
522 | 
523 |   Index index;
524 | 
525 |   constexpr EnumTagOnly() : index{0} {}
526 | 
527 |   template <class T>
528 |   explicit constexpr EnumTagOnly(T &&) : index{IndexGetter<T>::result} {}
529 | 
530 |   constexpr Index get_index() const { return index; }
531 | 
532 |   crust_cxx14_constexpr void set_index(Index index) { this->index = index; }
533 | 
534 |   template <class T>
535 |   constexpr const T &unsafe_get_variant() const {
536 |     return _impl_types::ZeroSizedTypeGetter<
537 |         _impl_types::TypesFirstIndex<T, _impl_types::Types<Fields...>>::result,
538 |         Fields...>::inner(*this);
539 |   }
540 | 
541 |   template <class T>
542 |   crust_cxx14_constexpr T &unsafe_get_variant() {
543 |     return _impl_types::ZeroSizedTypeGetter<
544 |         _impl_types::TypesFirstIndex<T, _impl_types::Types<Fields...>>::result,
545 |         Fields...>::inner(*this);
546 |   }
547 | 
548 |   template <class T>
549 |   constexpr bool is_variant() const {
550 |     return get_index() == IndexGetter<T>::result;
551 |   }
552 | 
553 |   template <class R = void, class V>
554 |   constexpr R visit(V &&visitor) const {
555 |     return Getter::template inner<R, V>(*this, forward<V>(visitor));
556 |   }
557 | 
558 |   template <class R = void, class V>
559 |   crust_cxx14_constexpr R visit(V &&visitor) {
560 |     return Getter::template inner<R, V>(*this, forward<V>(visitor));
561 |   }
562 | 
563 |   // FIXME: to make it constexpr, we cannot compare the real type here
564 |   constexpr bool eq(const EnumTagOnly &other) const {
565 |     return index == other.index;
566 |   }
567 | 
568 |   constexpr bool ne(const EnumTagOnly &other) const {
569 |     return index != other.index;
570 |   }
571 | 
572 |   constexpr Option<cmp::Ordering> partial_cmp(const EnumTagOnly &other) const;
573 | 
574 |   constexpr bool lt(const EnumTagOnly &other) const {
575 |     return index < other.index;
576 |   }
577 | 
578 |   constexpr bool le(const EnumTagOnly &other) const {
579 |     return index <= other.index;
580 |   }
581 | 
582 |   constexpr bool gt(const EnumTagOnly &other) const {
583 |     return index > other.index;
584 |   }
585 | 
586 |   constexpr bool ge(const EnumTagOnly &other) const {
587 |     return index >= other.index;
588 |   }
589 | 
590 |   constexpr cmp::Ordering cmp(const EnumTagOnly &other) const;
591 | };
592 | 
593 | template <class hint, bool is_tag_only, class... Fields>
594 | struct EnumSelectImpl;
595 | 
596 | template <class hint, class... Fields>
597 | struct EnumSelectImpl<hint, false, Fields...> : EnumTagUnion<hint, Fields...> {
598 |   CRUST_USE_BASE_CONSTRUCTORS(EnumSelectImpl, EnumTagUnion<hint, Fields...>);
599 | };
600 | 
601 | template <class hint, class... Fields>
602 | struct EnumSelectImpl<hint, true, Fields...> : EnumTagOnly<hint, Fields...> {
603 |   CRUST_USE_BASE_CONSTRUCTORS(EnumSelectImpl, EnumTagOnly<hint, Fields...>);
604 | };
605 | 
606 | // TODO: auto detect
607 | template <class... Fields>
608 | struct EnumSelectImpl<void, false, Fields...> : EnumTagUnion<i32, Fields...> {
609 |   CRUST_USE_BASE_CONSTRUCTORS(EnumSelectImpl, EnumTagUnion<i32, Fields...>);
610 | };
611 | 
612 | template <class... Fields>
613 | struct EnumSelectImpl<void, true, Fields...> : EnumTagOnly<i32, Fields...> {
614 |   CRUST_USE_BASE_CONSTRUCTORS(EnumSelectImpl, EnumTagOnly<i32, Fields...>);
615 | };
616 | 
617 | template <class hint, class... Fields>
618 | using EnumSelect = EnumSelectImpl<
619 |     hint,
620 |     All<Require<Fields, ZeroSizedType>...>::result,
621 |     Fields...>;
622 | 
623 | template <class T>
624 | struct LetEnum;
625 | 
626 | template <class... Ts>
627 | struct crust_ebco Overloaded;
628 | 
629 | template <class T, class... Ts>
630 | struct Overloaded<T, Ts...> : T, Overloaded<Ts...> {
631 |   using T::operator();
632 |   using Overloaded<Ts...>::operator();
633 | 
634 |   explicit constexpr Overloaded(T t, Ts... ts) :
635 |       T{forward<T>(t)}, Overloaded<Ts...>{forward<Ts>(ts)...} {}
636 | };
637 | 
638 | template <class T>
639 | struct Overloaded<T> : T {
640 |   using T::operator();
641 | 
642 |   explicit constexpr Overloaded(T t) : T{forward<T>(t)} {}
643 | };
644 | 
645 | template <class... Ts>
646 | constexpr Overloaded<Ts...> overloaded(Ts &&...ts) {
647 |   return Overloaded<Ts...>{forward<Ts>(ts)...};
648 | }
649 | 
650 | CRUST_TRAIT(EnumAs, class Inner) {
651 |   CRUST_TRAIT_USE_SELF(EnumAs);
652 | 
653 |   constexpr typename Inner::Index as() const {
654 |     return self().inner.get_index();
655 |   }
656 | };
657 | 
658 | template <class Inner, class... Fields>
659 | struct Enum :
660 |     InheritIf<
661 |         EnumAs<Enum<Inner, Fields...>, Inner>,
662 |         All<Require<Fields, ZeroSizedType>...>> {
663 | private:
664 |   crust_static_assert(sizeof...(Fields) > 0);
665 |   crust_static_assert(Not<_impl_types::TypesDuplicateVal<
666 |                           _impl_types::Types<Fields...>>>::result);
667 |   crust_static_assert(All<Not<IsConstOrRefVal<Fields>>...>::result);
668 | 
669 |   template <class>
670 |   friend struct LetEnum;
671 | 
672 |   template <class, class>
673 |   friend struct EnumAs;
674 | 
675 |   template <class, class>
676 |   friend struct ::crust::ImplFor;
677 | 
678 |   Inner inner;
679 | 
680 | protected:
681 |   constexpr Enum() : inner{} {}
682 | 
683 |   template <
684 |       class T,
685 |       class = EnableIf<
686 |           Not<IsBaseOfVal<Enum, typename RemoveConstOrRefType<T>::Result>>>>
687 |   constexpr Enum(T &&value) : inner{forward<T>(value)} {}
688 | 
689 |   template <class T>
690 |   constexpr bool is_variant() const {
691 |     return inner.template is_variant<T>();
692 |   }
693 | 
694 |   template <class T>
695 |   crust_cxx14_constexpr Option<T> move_variant() &&;
696 | 
697 |   template <class T>
698 |   crust_cxx14_constexpr bool let_helper(T &ref) && {
699 |     if (is_variant<T>()) {
700 |       ref = move(inner.template unsafe_get_variant<T>());
701 |       return true;
702 |     } else {
703 |       return false;
704 |     }
705 |   }
706 | 
707 | public:
708 |   template <
709 |       class T,
710 |       class = EnableIf<
711 |           Not<IsBaseOfVal<Enum, typename RemoveConstOrRefType<T>::Result>>>>
712 |   Enum &operator=(T &&value) {
713 |     inner = Inner{forward<T>(value)};
714 |     return *this;
715 |   }
716 | 
717 |   template <class R = void, class... Fs>
718 |   constexpr R visit(Fs &&...fs) const {
719 |     return inner.template visit<R>(overloaded(forward<Fs>(fs)...));
720 |   }
721 | 
722 |   template <class R = void, class... Fs>
723 |   crust_cxx14_constexpr R visit(Fs &&...fs) {
724 |     return inner.template visit<R>(overloaded(forward<Fs>(fs)...));
725 |   }
726 | 
727 |   template <class T, class R = void, class... Fs>
728 |   constexpr R visit_variant(Fs &&...fs) const {
729 |     return is_variant<T>() ?
730 |         overloaded(forward<Fs>(fs)...)(inner.template unsafe_get_variant<T>()) :
731 |         overloaded(forward<Fs>(fs)...)();
732 |   }
733 | 
734 |   template <class T, class R = void, class... Fs>
735 |   crust_cxx14_constexpr R visit_variant(Fs &&...fs) {
736 |     return is_variant<T>() ?
737 |         overloaded(forward<Fs>(fs)...)(inner.template unsafe_get_variant<T>()) :
738 |         overloaded(forward<Fs>(fs)...)();
739 |   }
740 | };
741 | 
742 | // TODO: option like enum
743 | 
744 | // template<class Field>
745 | // struct Enum<void, Field> {
746 | //   // TODO: only one possibility, this is just Field
747 | // };
748 | } // namespace _impl_enum
749 | 
750 | template <class Inner, class... Fields>
751 | CRUST_IMPL_FOR(
752 |     CRUST_MACRO(_impl_enum::EnumAs<_impl_enum::Enum<Inner, Fields...>, Inner>),
753 |     Require<Fields, ZeroSizedType>...){};
754 | 
755 | template <class Type>
756 | struct EnumRepr : TmplType<Type> {};
757 | 
758 | template <class... Fields>
759 | struct crust_ebco Enum :
760 |     _impl_enum::Enum<_impl_enum::EnumSelect<void, Fields...>, Fields...> {
761 |   CRUST_USE_BASE_CONSTRUCTORS(
762 |       Enum,
763 |       _impl_enum::Enum<_impl_enum::EnumSelect<void, Fields...>, Fields...>);
764 | };
765 | 
766 | template <class Type, class... Fields>
767 | struct crust_ebco Enum<EnumRepr<Type>, Fields...> :
768 |     _impl_enum::Enum<_impl_enum::EnumSelect<Type, Fields...>, Fields...> {
769 |   CRUST_USE_BASE_CONSTRUCTORS(
770 |       Enum,
771 |       _impl_enum::Enum<_impl_enum::EnumSelect<Type, Fields...>, Fields...>);
772 | };
773 | 
774 | namespace _impl_derive {
775 | template <class T, template <class, class...> class Trait, class... Args>
776 | struct ImplForEnumHelper : TmplVal<bool, false> {};
777 | 
778 | template <
779 |     class... Fields,
780 |     template <class, class...>
781 |     class Trait,
782 |     class... Args>
783 | struct ImplForEnumHelper<Enum<Fields...>, Trait, Args...> :
784 |     All<Require<Fields, Trait, Args...>...> {};
785 | 
786 | template <class T, template <class, class...> class Trait, class... Args>
787 | using ImplForEnum =
788 |     ImplForEnumHelper<typename BluePrint<T>::Result, Trait, Args...>;
789 | } // namespace _impl_derive
790 | 
791 | template <class S>
792 | CRUST_IMPL_FOR(clone::Clone<S>, _impl_derive::ImplForEnum<S, clone::Clone>) {
793 |   CRUST_IMPL_USE_SELF(S);
794 | 
795 | private:
796 |   struct Clone {
797 |     template <class T>
798 |     Self operator()(const T &value) {
799 |       return clone::clone(value);
800 |     }
801 |   };
802 | 
803 | public:
804 |   Self clone() const { return self().template visit<Self>(Clone{}); }
805 | };
806 | 
807 | template <class S>
808 | CRUST_IMPL_FOR(
809 |     cmp::PartialEq<S>, _impl_derive::ImplForEnum<S, cmp::PartialEq>) {
810 |   CRUST_IMPL_USE_SELF(S);
811 | 
812 |   constexpr bool eq(const Self &other) const {
813 |     return self().inner.eq(other.inner);
814 |   }
815 | 
816 |   constexpr bool ne(const Self &other) const {
817 |     return self().inner.ne(other.inner);
818 |   }
819 | };
820 | 
821 | template <class S>
822 | CRUST_IMPL_FOR(cmp::Eq<S>, _impl_derive::ImplForEnum<S, cmp::Eq>){};
823 | 
824 | template <class S>
825 | CRUST_IMPL_FOR(
826 |     cmp::PartialOrd<S>, _impl_derive::ImplForEnum<S, cmp::PartialOrd>) {
827 |   CRUST_IMPL_USE_SELF(S);
828 | 
829 |   constexpr Option<cmp::Ordering> partial_cmp(const Self &other) const;
830 | 
831 |   constexpr bool lt(const Self &other) const {
832 |     return self().inner.lt(other.inner);
833 |   }
834 | 
835 |   constexpr bool le(const Self &other) const {
836 |     return self().inner.le(other.inner);
837 |   }
838 | 
839 |   constexpr bool gt(const Self &other) const {
840 |     return self().inner.gt(other.inner);
841 |   }
842 | 
843 |   constexpr bool ge(const Self &other) const {
844 |     return self().inner.ge(other.inner);
845 |   }
846 | };
847 | 
848 | template <class S>
849 | CRUST_IMPL_FOR(cmp::Ord<S>, _impl_derive::ImplForEnum<S, cmp::Ord>) {
850 |   CRUST_IMPL_USE_SELF(S);
851 | 
852 |   constexpr cmp::Ordering cmp(const Self &other) const;
853 | };
854 | } // namespace crust
855 | 
856 | 
857 | #endif // CRUST_ENUM_DECL_HPP
858 | 


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