1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
|
//
// immer: immutable data structures for C++
// Copyright (C) 2016, 2017, 2018 Juan Pedro Bolivar Puente
//
// This software is distributed under the Boost Software License, Version 1.0.
// See accompanying file LICENSE or copy at http://boost.org/LICENSE_1_0.txt
//
#include <immer/algorithm.hpp>
#include <immer/box.hpp>
#include <immer/flex_vector.hpp>
#include <immer/map.hpp>
#include <immer/set.hpp>
#include <immer/vector.hpp>
#include <catch.hpp>
struct rec_vec
{
int data;
immer::vector<immer::box<rec_vec>> children;
};
TEST_CASE("recursive vector")
{
auto v1 = rec_vec{42,
{rec_vec{12, {}},
rec_vec{13, {rec_vec{5, {}}, rec_vec{7, {}}}},
rec_vec{15, {}}}};
CHECK(v1.data == 42);
CHECK(v1.children[0]->data == 12);
CHECK(v1.children[1]->children[0]->data == 5);
}
struct rec_fvec
{
int data;
immer::flex_vector<immer::box<rec_fvec>> children;
};
TEST_CASE("recursive flex_vector")
{
auto v1 = rec_fvec{42,
{rec_fvec{12, {}},
rec_fvec{13, {rec_fvec{5, {}}, rec_fvec{7, {}}}},
rec_fvec{15, {}}}};
CHECK(v1.data == 42);
CHECK(v1.children[0]->data == 12);
CHECK(v1.children[1]->children[0]->data == 5);
}
struct rec_map
{
int data;
immer::map<std::string, immer::box<rec_map>> children;
};
TEST_CASE("recursive map")
{
auto v1 = rec_map{42, {}};
auto v2 = rec_map{43, v1.children.set("hello", rec_map{12, {}})};
auto v3 = rec_map{44, v2.children.set("world", rec_map{13, {}})};
CHECK(v3.data == 44);
CHECK(v3.children["hello"]->data == 12);
CHECK(v3.children["world"]->data == 13);
}
struct rec_set
{
int data;
immer::set<immer::box<rec_set>> children;
bool operator==(const rec_set& other) const
{
return data == other.data && children == other.children;
}
bool operator!=(const rec_set& other) const { return !(*this == other); }
};
namespace std {
template <>
struct hash<rec_set>
{
auto operator()(const rec_set& s)
{
return std::hash<decltype(s.data)>{}(s.data) ^
immer::accumulate(
s.children, std::size_t{}, [](auto ac, auto v) {
return std::hash<decltype(v)>{}(v);
});
}
};
} // namespace std
TEST_CASE("recursive set")
{
auto v1 = rec_set{42, {}};
auto v2 = rec_set{43, v1.children.insert(rec_set{12, {}})};
auto v3 = rec_set{44, v2.children.insert(rec_set{13, {}})};
CHECK(v3.data == 44);
CHECK(v3.children.count(rec_set{12, {}}) == 1);
CHECK(v3.children.count(rec_set{13, {}}) == 1);
CHECK(v3.children.count(rec_set{14, {}}) == 0);
}
|
