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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
|
// { dg-do compile }
// { dg-options "-g" }
typedef unsigned int uint32_t;
typedef unsigned long int uint64_t;
namespace mpl_ {
template< typename T, T N > struct integral_c {
static const T value = N;
};
}
namespace mpl {
using namespace mpl_;
};
template <class T, T val> struct integral_constant : public mpl::integral_c<T, val> {
typedef integral_constant<bool,false> type;
};
template< typename T > struct is_lvalue_reference : public ::integral_constant<bool,false> {
};
template< typename T > struct is_rvalue_reference : public ::integral_constant<bool,false> {
};
namespace type_traits {
template <bool b1, bool b2, bool b3 = false, bool b4 = false, bool b5 = false, bool b6 = false, bool b7 = false> struct ice_or;
template <> struct ice_or<false, false, false, false, false, false, false> {
static const bool value = false;
};
}
template <typename T> struct is_reference_impl {
static const bool value = (::type_traits::ice_or< ::is_lvalue_reference<T>::value, ::is_rvalue_reference<T>::value >::value) ;
};
template< typename T > struct is_reference : public ::integral_constant<bool,::is_reference_impl<T>::value> {
};
struct na {
};
namespace mpl {
template< bool C , typename T1 , typename T2 > struct if_c {
typedef T2 type;
};
template< typename T1 = na , typename T2 = na , typename T3 = na > struct if_ {
typedef if_c< static_cast<bool>(T1::value) , T2 , T3 > almost_type_;
typedef typename almost_type_::type type;
};
}
namespace optional_detail {
template<class T> struct types_when_isnt_ref {
typedef T & reference_type ;
}
;
template<class T> struct types_when_is_ref {
}
;
struct optional_tag {
}
;
template<class T> class optional_base : public optional_tag {
typedef types_when_isnt_ref<T> types_when_not_ref ;
typedef types_when_is_ref<T> types_when_ref ;
protected :
typedef typename is_reference<T>::type is_reference_predicate ;
typedef typename mpl::if_<is_reference_predicate,types_when_ref,types_when_not_ref>::type types ;
typedef typename types::reference_type reference_type ;
}
;
}
template<class T> class optional : public optional_detail::optional_base<T> {
typedef optional_detail::optional_base<T> base ;
public :
typedef typename base::reference_type reference_type ;
reference_type operator *() {
}
};
namespace noncopyable_ {
class noncopyable {
};
}
typedef noncopyable_::noncopyable noncopyable;
template<class T> class shared_ptr {
public:
T * operator-> () const {
}
};
typedef uint64_t block_address;
class transaction_manager : noncopyable {
public:
typedef shared_ptr<transaction_manager> ptr;
};
template <typename ValueType> class NoOpRefCounter {
};
struct uint64_traits {
};
namespace btree_detail {
class shadow_spine : private noncopyable {
public:
shadow_spine(transaction_manager::ptr tm) : tm_(tm) {
}
transaction_manager::ptr tm_;
};
}
template <unsigned Levels, typename ValueTraits> class btree {
public:
typedef shared_ptr<btree<Levels, ValueTraits> > ptr;
typedef uint64_t key[Levels];
typedef typename ValueTraits::value_type value_type;
typedef optional<value_type> maybe_value;
btree(typename transaction_manager::ptr tm, typename ValueTraits::ref_counter rc);
maybe_value lookup(key const &key) const;
void insert(key const &key, typename ValueTraits::value_type const &value);
template <typename ValueTraits2> bool insert_location(btree_detail::shadow_spine &spine, block_address block, uint64_t key, int *index);
typename transaction_manager::ptr tm_;
block_address root_;
typename ValueTraits::ref_counter rc_;
};
template <unsigned Levels, typename ValueTraits> void btree<Levels, ValueTraits>:: insert(key const &key, typename ValueTraits::value_type const &value) {
using namespace btree_detail;
block_address block = root_;
int index = 0;
shadow_spine spine(tm_);
for (unsigned level = 0;
level < Levels - 1;
++level) {
bool need_insert = insert_location<uint64_traits>(spine, block, key[level], &index);
if (need_insert) {
btree<Levels - 1, ValueTraits> new_tree(tm_, rc_);
}
}
}
struct device_details_disk {
}
__attribute__ ((packed));
struct device_details {
};
struct device_details_traits {
typedef device_details value_type;
typedef NoOpRefCounter<device_details> ref_counter;
};
typedef uint32_t thin_dev_t;
typedef btree<1, device_details_traits> detail_tree;
struct metadata {
typedef shared_ptr<metadata> ptr;
detail_tree::ptr details_;
};
class thin_pool;
class thin {
void set_snapshot_time(uint32_t time);
thin_dev_t dev_;
thin_pool *pool_;
};
class thin_pool {
public:
metadata::ptr md_;
};
void thin::set_snapshot_time(uint32_t time) {
uint64_t key[1] = {
dev_ };
optional<device_details> mdetail = pool_->md_->details_->lookup(key);
pool_->md_->details_->insert(key, *mdetail);
}
|
