46#ifndef _THROW_ALLOCATOR_H
47#define _THROW_ALLOCATOR_H 1
58#if __cplusplus >= 201103L
62# include <tr1/functional>
67# if !__has_builtin(__builtin_sprintf)
69# define _GLIBCXX_NO_BUILTIN_SPRINTF
73namespace __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)
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);
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());
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);
377#if __cplusplus >= 201103L
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;
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>
686 operator==(
const throw_value_base<_Cond>& __a,
687 const throw_value_base<_Cond>& __b)
689 typedef throw_value_base<_Cond> throw_value;
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,
698 const throw_value_base<_Cond>& __b)
700 typedef throw_value_base<_Cond> throw_value;
701 throw_value::throw_conditionally();
702 bool __ret = __a._M_i < __b._M_i;
707 template<
typename _Cond>
708 inline throw_value_base<_Cond>
709 operator+(
const throw_value_base<_Cond>& __a,
710 const throw_value_base<_Cond>& __b)
712 typedef throw_value_base<_Cond> throw_value;
713 throw_value::throw_conditionally();
714 throw_value __ret(__a._M_i + __b._M_i);
718 template<
typename _Cond>
719 inline throw_value_base<_Cond>
720 operator-(
const throw_value_base<_Cond>& __a,
721 const throw_value_base<_Cond>& __b)
723 typedef throw_value_base<_Cond> throw_value;
724 throw_value::throw_conditionally();
725 throw_value __ret(__a._M_i - __b._M_i);
729 template<
typename _Cond>
730 inline throw_value_base<_Cond>
731 operator*(
const throw_value_base<_Cond>& __a,
732 const throw_value_base<_Cond>& __b)
734 typedef throw_value_base<_Cond> throw_value;
735 throw_value::throw_conditionally();
736 throw_value __ret(__a._M_i * __b._M_i);
746#ifndef _GLIBCXX_IS_AGGREGATE
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
784#if __cplusplus >= 201103L
794 base_type::operator=(__other);
798#if __cplusplus >= 201103L
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>
916 operator!=(
const throw_allocator_base<_Tp, _Cond>&,
917 const throw_allocator_base<_Tp, _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 { }
964_GLIBCXX_END_NAMESPACE_VERSION
967#undef _GLIBCXX_NO_BUILTIN_SPRINTF
969#if __cplusplus >= 201103L
973namespace 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);
complex< _Tp > pow(const complex< _Tp > &, int)
Return x to the y'th power.
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.
constexpr _Tp * __addressof(_Tp &__r) noexcept
Same as C++11 std::addressof.
_GLIBCXX_END_NAMESPACE_CXX11 typedef basic_string< char > string
A string of char.
_Bind_helper< __is_socketlike< _Func >::value, _Func, _BoundArgs... >::type bind(_Func &&__f, _BoundArgs &&... __args)
Function template for std::bind.
mersenne_twister_engine< uint_fast32_t, 32, 624, 397, 31, 0x9908b0dfUL, 11, 0xffffffffUL, 7, 0x9d2c5680UL, 15, 0xefc60000UL, 18, 1812433253UL > mt19937
ISO C++ entities toplevel namespace is std.
reference_wrapper< _Tp > ref(_Tp &__t) noexcept
Denotes a reference should be taken to a variable.
constexpr const _Tp * end(initializer_list< _Tp > __ils) noexcept
Return an iterator pointing to one past the last element of the initializer_list.
GNU extensions for public use.
Properties of fundamental types.
Primary class template hash.
Base class for all library exceptions.
std::mersenne_twister_engine< uint_fast32_t, 32, 624, 397, 31, 0x9908b0dfUL, 11, 0xffffffffUL, 7, 0x9d2c5680UL, 15, 0xefc60000UL, 18, 1812433253UL >
Uniform continuous distribution for random numbers.
A standard container made up of (key,value) pairs, which can be retrieved based on a key,...
std::pair< iterator, bool > insert(const value_type &__x)
Attempts to insert a std::pair into the map.
iterator find(const key_type &__x)
Tries to locate an element in a map.
iterator erase(const_iterator __position)
Erases an element from a map.
iterator begin() noexcept
Struct holding two objects of arbitrary type.
_T1 first
second_type is the second bound type
_T2 second
first is a copy of the first object
Thown by exception safety machinery.
Base class for checking address and label information about allocations. Create a std::map between th...
Base struct for condition policy.
Base class for incremental control and throw.
Never enter the condition.
Always enter the condition.
Base class for random probability control and throw.
Never enter the condition.
Always enter the condition.
Class with exception generation control. Intended to be used as a value_type in templatized code.
Type throwing via limit condition.
Type throwing via random condition.
Allocator class with logging and exception generation control. Intended to be used as an allocator_ty...
Allocator throwing via limit condition.
Allocator throwing via random condition.