46 #ifndef _THROW_ALLOCATOR_H 47 #define _THROW_ALLOCATOR_H 1 58 #if __cplusplus >= 201103L 62 # include <tr1/functional> 63 # include <tr1/random> 67 # if !__has_builtin(__builtin_sprintf) 69 # define _GLIBCXX_NO_BUILTIN_SPRINTF 73 namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
75 _GLIBCXX_BEGIN_NAMESPACE_VERSION
86 __throw_forced_error()
101 typedef map_alloc_type::const_iterator const_iterator;
102 typedef map_alloc_type::const_reference const_reference;
103 #if __cplusplus >= 201103L 123 insert(
void* p,
size_t size)
125 entry_type entry = make_entry(p, size);
128 std::string error(
"annotate_base::insert null insert!\n");
129 log_to_string(error, entry);
130 std::__throw_logic_error(error.c_str());
134 = map_alloc().insert(entry);
135 if (!inserted.second)
137 std::string error(
"annotate_base::insert double insert!\n");
138 log_to_string(error, entry);
139 log_to_string(error, *inserted.first);
140 std::__throw_logic_error(error.c_str());
145 erase(
void* p,
size_t size)
146 { map_alloc().erase(check_allocated(p, size)); }
148 #if __cplusplus >= 201103L 150 insert_construct(
void* p)
154 std::string error(
"annotate_base::insert_construct null!\n");
155 std::__throw_logic_error(error.c_str());
158 auto inserted = map_construct().insert(
std::make_pair(p, get_label()));
159 if (!inserted.second)
161 std::string error(
"annotate_base::insert_construct double insert!\n");
163 log_to_string(error, *inserted.first);
164 std::__throw_logic_error(error.c_str());
169 erase_construct(
void* p)
170 { map_construct().erase(check_constructed(p)); }
174 inline map_alloc_type::iterator
175 check_allocated(
void* p,
size_t size)
177 map_alloc_type::iterator found = map_alloc().find(p);
178 if (found == map_alloc().
end())
180 std::string error(
"annotate_base::check_allocated by value " 182 log_to_string(error, make_entry(p, size));
183 std::__throw_logic_error(error.c_str());
186 if (found->second.second != size)
188 std::string error(
"annotate_base::check_allocated by value " 189 "wrong-size erase!\n");
190 log_to_string(error, make_entry(p, size));
191 log_to_string(error, *found);
192 std::__throw_logic_error(error.c_str());
204 const_iterator beg = map_alloc().
begin();
205 const_iterator
end = map_alloc().end();
208 if (beg->second.first == label)
209 log_to_string(found, *beg);
214 #if __cplusplus >= 201103L 216 auto beg = map_construct().begin();
217 auto end = map_construct().end();
220 if (beg->second == label)
221 log_to_string(found, *beg);
229 std::string error(
"annotate_base::check by label\n");
231 std::__throw_logic_error(error.c_str());
241 const_iterator beg = map_alloc().
begin();
242 const_iterator
end = map_alloc().end();
245 log_to_string(found, *beg);
250 #if __cplusplus >= 201103L 252 auto beg = map_construct().begin();
253 auto end = map_construct().end();
256 log_to_string(found, *beg);
266 std::__throw_logic_error(error.c_str());
270 #if __cplusplus >= 201103L 271 inline map_construct_type::iterator
272 check_constructed(
void* p)
274 auto found = map_construct().find(p);
275 if (found == map_construct().
end())
277 std::string error(
"annotate_base::check_constructed not " 280 std::__throw_logic_error(error.c_str());
287 check_constructed(
size_t label)
289 auto beg = map_construct().begin();
290 auto end = map_construct().end();
294 if (beg->second == label)
295 log_to_string(found, *beg);
301 std::string error(
"annotate_base::check_constructed by label\n");
303 std::__throw_logic_error(error.c_str());
313 make_entry(
void* p,
size_t size)
319 #ifdef _GLIBCXX_NO_BUILTIN_SPRINTF 320 __typeof__(&std::sprintf) __builtin_sprintf = &std::sprintf;
324 const char tab(
'\t');
326 unsigned long l =
static_cast<unsigned long>(ref.second.first);
327 __builtin_sprintf(buf,
"%lu", l);
331 l =
static_cast<unsigned long>(ref.second.second);
332 __builtin_sprintf(buf,
"%lu", l);
336 __builtin_sprintf(buf,
"%p", ref.first);
341 #if __cplusplus >= 201103L 345 #ifdef _GLIBCXX_NO_BUILTIN_SPRINTF 346 auto __builtin_sprintf = &std::sprintf;
350 const char tab(
'\t');
352 unsigned long l =
static_cast<unsigned long>(ref.
second);
353 __builtin_sprintf(buf,
"%lu", l);
357 __builtin_sprintf(buf,
"%p", ref.
first);
370 static map_alloc_type&
373 static map_alloc_type _S_map;
377 #if __cplusplus >= 201103L 378 static map_construct_type&
381 static map_construct_type _S_map;
393 base_type::const_iterator beg = __b.map_alloc().
begin();
394 base_type::const_iterator
end = __b.map_alloc().
end();
395 for (; beg !=
end; ++beg)
396 __b.log_to_string(error, *beg);
398 #if __cplusplus >= 201103L 400 auto beg = __b.map_construct().
begin();
401 auto end = __b.map_construct().
end();
402 for (; beg !=
end; ++beg)
403 __b.log_to_string(error, *beg);
418 #if __cplusplus >= 201103L 438 const size_t _M_orig;
441 adjustor_base() : _M_orig(limit()) { }
444 ~adjustor_base() { set_limit(_M_orig); }
468 throw_conditionally()
470 if (count() == limit())
471 __throw_forced_error();
478 static size_t _S_count(0);
491 set_limit(
const size_t __l)
498 #ifdef _GLIBCXX_USE_C99_STDINT_TR1 510 const double _M_orig;
513 adjustor_base() : _M_orig(probability()) { }
515 virtual ~adjustor_base()
516 { set_probability(_M_orig); }
523 { set_probability(1 -
std::pow(
double(1 - probability()),
524 double(0.5 / (size + 1))));
547 set_probability(
double __p)
548 { probability() = __p; }
551 throw_conditionally()
553 if (generate() < probability())
554 __throw_forced_error();
558 seed(
unsigned long __s)
559 { engine().seed(__s); }
562 #if __cplusplus >= 201103L 566 typedef std::tr1::uniform_real<double> distribution_type;
573 #if __cplusplus >= 201103L 574 const distribution_type distribution(0, 1);
575 static auto generator =
std::bind(distribution, engine());
578 typedef std::tr1::variate_generator<engine_type, distribution_type> gen_t;
579 distribution_type distribution(0, 1);
580 static gen_t generator(engine(), distribution);
583 #ifdef _GLIBCXX_NO_BUILTIN_SPRINTF 584 __typeof__(&std::sprintf) __builtin_sprintf = &std::sprintf;
587 double random = generator();
588 if (random < distribution.
min() || random > distribution.
max())
592 __s +=
"random number generated is: ";
594 __builtin_sprintf(buf,
"%f", random);
596 std::__throw_out_of_range(__s.c_str());
612 static engine_type _S_e;
616 #endif // _GLIBCXX_USE_C99_STDINT_TR1 624 template<
typename _Cond>
627 typedef _Cond condition_type;
629 using condition_type::throw_conditionally;
633 #ifndef _GLIBCXX_IS_AGGREGATE 635 { throw_conditionally(); }
638 { throw_conditionally(); }
640 #if __cplusplus >= 201103L 646 { throw_conditionally(); }
652 throw_conditionally();
657 #if __cplusplus >= 201103L 666 throw_conditionally();
672 template<
typename _Cond>
677 throw_value::throw_conditionally();
678 throw_value orig(__a);
684 template<
typename _Cond>
690 throw_value::throw_conditionally();
691 bool __ret = __a._M_i == __b._M_i;
695 template<
typename _Cond>
697 operator<(const throw_value_base<_Cond>& __a,
701 throw_value::throw_conditionally();
702 bool __ret = __a._M_i < __b._M_i;
707 template<
typename _Cond>
713 throw_value::throw_conditionally();
714 throw_value __ret(__a._M_i + __b._M_i);
718 template<
typename _Cond>
724 throw_value::throw_conditionally();
725 throw_value __ret(__a._M_i - __b._M_i);
729 template<
typename _Cond>
735 throw_value::throw_conditionally();
736 throw_value __ret(__a._M_i * __b._M_i);
746 #ifndef _GLIBCXX_IS_AGGREGATE 750 : base_type(__other._M_i) { }
752 #if __cplusplus >= 201103L 762 base_type::operator=(__other);
766 #if __cplusplus >= 201103L 772 #ifdef _GLIBCXX_USE_C99_STDINT_TR1 778 #ifndef _GLIBCXX_IS_AGGREGATE 782 : base_type(__other._M_i) { }
784 #if __cplusplus >= 201103L 794 base_type::operator=(__other);
798 #if __cplusplus >= 201103L 803 #endif // _GLIBCXX_USE_C99_STDINT_TR1 812 template<
typename _Tp,
typename _Cond>
817 typedef size_t size_type;
818 typedef ptrdiff_t difference_type;
819 typedef _Tp value_type;
820 typedef value_type* pointer;
821 typedef const value_type* const_pointer;
822 typedef value_type& reference;
823 typedef const value_type& const_reference;
825 #if __cplusplus >= 201103L 832 typedef _Cond condition_type;
836 using condition_type::throw_conditionally;
840 max_size()
const _GLIBCXX_USE_NOEXCEPT
841 {
return _M_allocator.max_size(); }
844 address(reference __x)
const _GLIBCXX_NOEXCEPT
848 address(const_reference __x)
const _GLIBCXX_NOEXCEPT
851 _GLIBCXX_NODISCARD pointer
854 if (__n > this->max_size())
855 std::__throw_bad_alloc();
857 throw_conditionally();
858 pointer
const a = _M_allocator.allocate(__n, hint);
859 insert(a,
sizeof(value_type) * __n);
863 #if __cplusplus >= 201103L 864 template<
typename _Up,
typename... _Args>
866 construct(_Up* __p, _Args&&... __args)
868 _M_allocator.construct(__p, std::forward<_Args>(__args)...);
869 insert_construct(__p);
872 template<
typename _Up>
876 erase_construct(__p);
877 _M_allocator.destroy(__p);
881 construct(pointer __p,
const value_type& val)
882 {
return _M_allocator.construct(__p, val); }
886 { _M_allocator.destroy(__p); }
890 deallocate(pointer __p, size_type __n)
892 erase(__p,
sizeof(value_type) * __n);
893 _M_allocator.deallocate(__p, __n);
897 check_allocated(pointer __p, size_type __n)
899 size_type __t =
sizeof(value_type) * __n;
900 annotate_base::check_allocated(__p, __t);
905 { annotate_base::check(__n); }
908 template<
typename _Tp,
typename _Cond>
914 template<
typename _Tp,
typename _Cond>
921 template<
typename _Tp>
925 template<
typename _Tp1>
932 _GLIBCXX_USE_NOEXCEPT { }
934 template<
typename _Tp1>
936 _GLIBCXX_USE_NOEXCEPT { }
941 #ifdef _GLIBCXX_USE_C99_STDINT_TR1 943 template<
typename _Tp>
947 template<
typename _Tp1>
954 _GLIBCXX_USE_NOEXCEPT { }
956 template<
typename _Tp1>
958 _GLIBCXX_USE_NOEXCEPT { }
962 #endif // _GLIBCXX_USE_C99_STDINT_TR1 964 _GLIBCXX_END_NAMESPACE_VERSION
967 #undef _GLIBCXX_NO_BUILTIN_SPRINTF 969 #if __cplusplus >= 201103L 973 namespace std _GLIBCXX_VISIBILITY(default)
983 __gnu_cxx::throw_value_limit::throw_conditionally();
985 size_t __result = __h(__val._M_i);
990 #ifdef _GLIBCXX_USE_C99_STDINT_TR1 999 __gnu_cxx::throw_value_random::throw_conditionally();
1001 size_t __result = __h(__val._M_i);
constexpr pair< typename __decay_and_strip< _T1 >::__type, typename __decay_and_strip< _T2 >::__type > make_pair(_T1 &&__x, _T2 &&__y)
A convenience wrapper for creating a pair from two objects.
_GLIBCXX_END_NAMESPACE_CXX11 typedef basic_string< char > string
A string of char.
Template class basic_ostream.
Base class for incremental control and throw.
Struct holding two objects of arbitrary type.
iterator begin() noexcept
Base struct for condition policy.
Never enter the condition.
Base class for random probability control and throw.
Base class for checking address and label information about allocations. Create a std::map between th...
Thown by exception safety machinery.
Allocator throwing via limit condition.
GNU extensions for public use.
Never enter the condition.
Type throwing via limit condition.
complex< _Tp > pow(const complex< _Tp > &, int)
Return x to the y'th power.
A standard container made up of (key,value) pairs, which can be retrieved based on a key...
constexpr const _Tp * end(initializer_list< _Tp > __ils) noexcept
Return an iterator pointing to one past the last element of the initializer_list. ...
Primary class template hash.
reference_wrapper< _Tp > ref(_Tp &__t) noexcept
Denotes a reference should be taken to a variable.
ISO C++ entities toplevel namespace is std.
Type throwing via random condition.
Class with exception generation control. Intended to be used as a value_type in templatized code...
_T2 second
first is a copy of the first object
Allocator class with logging and exception generation control. Intended to be used as an allocator_ty...
Uniform continuous distribution for random numbers.
_T1 first
second_type is the second bound type
Properties of fundamental types.
_Bind_helper< __is_socketlike< _Func >::value, _Func, _BoundArgs... >::type bind(_Func &&__f, _BoundArgs &&...__args)
Function template for std::bind.
Always enter the condition.
mersenne_twister_engine< uint_fast32_t, 32, 624, 397, 31, 0x9908b0dfUL, 11, 0xffffffffUL, 7, 0x9d2c5680UL, 15, 0xefc60000UL, 18, 1812433253UL > mt19937
Base class for all library exceptions.
result_type min() const
Returns the inclusive lower bound of the distribution range.
std::mersenne_twister_engine< uint_fast32_t, 32, 624, 397, 31, 0x9908b0dfUL, 11, 0xffffffffUL, 7, 0x9d2c5680UL, 15, 0xefc60000UL, 18, 1812433253UL >
Always enter the condition.
Allocator throwing via random condition.
constexpr _Tp * __addressof(_Tp &__r) noexcept
Same as C++11 std::addressof.
result_type max() const
Returns the inclusive upper bound of the distribution range.