46 #ifndef _THROW_ALLOCATOR_H
47 #define _THROW_ALLOCATOR_H 1
58 #if __cplusplus >= 201103L
59 # include <functional>
62 # include <tr1/functional>
63 # include <tr1/random>
66 namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
68 _GLIBCXX_BEGIN_NAMESPACE_VERSION
79 __throw_forced_error()
105 insert(
void* p,
size_t size)
109 std::string error(
"annotate_base::insert null insert!\n");
110 log_to_string(error, make_entry(p, size));
111 std::__throw_logic_error(error.
c_str());
114 const_iterator found = map().
find(p);
115 if (found != map().
end())
117 std::string error(
"annotate_base::insert double insert!\n");
118 log_to_string(error, make_entry(p, size));
119 log_to_string(error, *found);
120 std::__throw_logic_error(error.
c_str());
123 map().
insert(make_entry(p, size));
127 erase(
void* p,
size_t size)
129 check_allocated(p, size);
135 check_allocated(
void* p,
size_t size)
137 const_iterator found = map().
find(p);
138 if (found == map().
end())
140 std::string error(
"annotate_base::check_allocated by value "
142 log_to_string(error, make_entry(p, size));
143 std::__throw_logic_error(error.
c_str());
146 if (found->second.second != size)
148 std::string error(
"annotate_base::check_allocated by value "
149 "wrong-size erase!\n");
150 log_to_string(error, make_entry(p, size));
151 log_to_string(error, *found);
152 std::__throw_logic_error(error.
c_str());
158 check_allocated(
size_t label)
160 const_iterator beg = map().
begin();
161 const_iterator
end = map().
end();
165 if (beg->second.first == label)
166 log_to_string(found, *beg);
172 std::string error(
"annotate_base::check_allocated by label\n");
174 std::__throw_logic_error(error.
c_str());
182 typedef map_type::const_iterator const_iterator;
183 typedef map_type::const_reference const_reference;
189 make_entry(
void* p,
size_t size)
193 log_to_string(
std::string& s, const_reference ref)
const
196 const char tab(
'\t');
198 unsigned long l =
static_cast<unsigned long>(ref.second.first);
199 __builtin_sprintf(buf,
"%lu", l);
203 l =
static_cast<unsigned long>(ref.second.second);
204 __builtin_sprintf(buf,
"%lu", l);
208 __builtin_sprintf(buf,
"%p", ref.first);
223 static map_type _S_map;
233 base_type::const_iterator beg = __b.map().
begin();
234 base_type::const_iterator
end = __b.map().
end();
235 for (; beg !=
end; ++beg)
236 __b.log_to_string(error, *beg);
264 const size_t _M_orig;
267 adjustor_base() : _M_orig(limit()) { }
270 ~adjustor_base() { set_limit(_M_orig); }
294 throw_conditionally()
296 if (count() == limit())
297 __throw_forced_error();
304 static size_t _S_count(0);
317 set_limit(
const size_t __l)
336 const double _M_orig;
339 adjustor_base() : _M_orig(probability()) { }
341 virtual ~adjustor_base()
342 { set_probability(_M_orig); }
349 { set_probability(1 - std::pow(
double(1 - probability()),
350 double(0.5 / (size + 1))));
373 set_probability(
double __p)
374 { probability() = __p; }
377 throw_conditionally()
379 if (generate() < probability())
380 __throw_forced_error();
384 seed(
unsigned long __s)
385 { engine().seed(__s); }
388 #if __cplusplus >= 201103L
392 typedef std::tr1::uniform_real<double> distribution_type;
399 #if __cplusplus >= 201103L
400 const distribution_type distribution(0, 1);
401 static auto generator = std::bind(distribution, engine());
404 typedef std::tr1::variate_generator<engine_type, distribution_type> gen_t;
405 distribution_type distribution(0, 1);
406 static gen_t generator(engine(), distribution);
409 double random = generator();
410 if (random < distribution.min() || random > distribution.max())
414 __s +=
"random number generated is: ";
416 __builtin_sprintf(buf,
"%f", random);
418 std::__throw_out_of_range(__s.c_str());
434 static engine_type _S_e;
446 template<
typename _Cond>
449 typedef _Cond condition_type;
451 using condition_type::throw_conditionally;
455 #ifndef _GLIBCXX_IS_AGGREGATE
457 { throw_conditionally(); }
460 { throw_conditionally(); }
462 #if __cplusplus >= 201103L
468 { throw_conditionally(); }
474 throw_conditionally();
479 #if __cplusplus >= 201103L
488 throw_conditionally();
494 template<
typename _Cond>
499 throw_value::throw_conditionally();
500 throw_value orig(__a);
506 template<
typename _Cond>
508 operator==(
const throw_value_base<_Cond>& __a,
509 const throw_value_base<_Cond>& __b)
511 typedef throw_value_base<_Cond> throw_value;
512 throw_value::throw_conditionally();
513 bool __ret = __a._M_i == __b._M_i;
517 template<
typename _Cond>
519 operator<(const throw_value_base<_Cond>& __a,
520 const throw_value_base<_Cond>& __b)
522 typedef throw_value_base<_Cond> throw_value;
523 throw_value::throw_conditionally();
524 bool __ret = __a._M_i < __b._M_i;
529 template<
typename _Cond>
530 inline throw_value_base<_Cond>
531 operator+(
const throw_value_base<_Cond>& __a,
532 const throw_value_base<_Cond>& __b)
534 typedef throw_value_base<_Cond> throw_value;
535 throw_value::throw_conditionally();
536 throw_value __ret(__a._M_i + __b._M_i);
540 template<
typename _Cond>
541 inline throw_value_base<_Cond>
542 operator-(
const throw_value_base<_Cond>& __a,
543 const throw_value_base<_Cond>& __b)
545 typedef throw_value_base<_Cond> throw_value;
546 throw_value::throw_conditionally();
547 throw_value __ret(__a._M_i - __b._M_i);
551 template<
typename _Cond>
552 inline throw_value_base<_Cond>
553 operator*(
const throw_value_base<_Cond>& __a,
554 const throw_value_base<_Cond>& __b)
556 typedef throw_value_base<_Cond> throw_value;
557 throw_value::throw_conditionally();
558 throw_value __ret(__a._M_i * __b._M_i);
568 #ifndef _GLIBCXX_IS_AGGREGATE
572 : base_type(__other._M_i) { }
574 #if __cplusplus >= 201103L
584 base_type::operator=(__other);
588 #if __cplusplus >= 201103L
599 #ifndef _GLIBCXX_IS_AGGREGATE
603 : base_type(__other._M_i) { }
605 #if __cplusplus >= 201103L
615 base_type::operator=(__other);
619 #if __cplusplus >= 201103L
633 template<
typename _Tp,
typename _Cond>
638 typedef size_t size_type;
639 typedef ptrdiff_t difference_type;
640 typedef _Tp value_type;
641 typedef value_type* pointer;
642 typedef const value_type* const_pointer;
643 typedef value_type& reference;
644 typedef const value_type& const_reference;
646 #if __cplusplus >= 201103L
649 typedef std::true_type propagate_on_container_move_assignment;
653 typedef _Cond condition_type;
657 using condition_type::throw_conditionally;
661 max_size()
const _GLIBCXX_USE_NOEXCEPT
662 {
return _M_allocator.max_size(); }
665 address(reference __x)
const _GLIBCXX_NOEXCEPT
669 address(const_reference __x)
const _GLIBCXX_NOEXCEPT
675 if (__n > this->max_size())
676 std::__throw_bad_alloc();
678 throw_conditionally();
679 pointer
const a = _M_allocator.allocate(__n, hint);
680 insert(a,
sizeof(value_type) * __n);
684 #if __cplusplus >= 201103L
685 template<
typename _Up,
typename... _Args>
687 construct(_Up* __p, _Args&&... __args)
688 {
return _M_allocator.construct(__p, std::forward<_Args>(__args)...); }
690 template<
typename _Up>
693 { _M_allocator.destroy(__p); }
696 construct(pointer __p,
const value_type& val)
697 {
return _M_allocator.construct(__p, val); }
701 { _M_allocator.destroy(__p); }
705 deallocate(pointer __p, size_type __n)
707 erase(__p,
sizeof(value_type) * __n);
708 _M_allocator.deallocate(__p, __n);
712 check_allocated(pointer __p, size_type __n)
714 size_type __t =
sizeof(value_type) * __n;
715 annotate_base::check_allocated(__p, __t);
719 check_allocated(size_type __n)
720 { annotate_base::check_allocated(__n); }
723 template<
typename _Tp,
typename _Cond>
729 template<
typename _Tp,
typename _Cond>
731 operator!=(
const throw_allocator_base<_Tp, _Cond>&,
732 const throw_allocator_base<_Tp, _Cond>&)
736 template<
typename _Tp>
740 template<
typename _Tp1>
747 _GLIBCXX_USE_NOEXCEPT { }
749 template<
typename _Tp1>
751 _GLIBCXX_USE_NOEXCEPT { }
757 template<
typename _Tp>
761 template<
typename _Tp1>
768 _GLIBCXX_USE_NOEXCEPT { }
770 template<
typename _Tp1>
772 _GLIBCXX_USE_NOEXCEPT { }
777 _GLIBCXX_END_NAMESPACE_VERSION
780 #if __cplusplus >= 201103L
784 namespace std _GLIBCXX_VISIBILITY(default)
795 size_t __result = __h(__val._M_i);
809 size_t __result = __h(__val._M_i);
std::mersenne_twister_engine< uint_fast32_t, 32, 624, 397, 31, 0x9908b0dfUL, 11, 0xffffffffUL, 7, 0x9d2c5680UL, 15, 0xefc60000UL, 18, 1812433253UL >
Allocator class with logging and exception generation control. Intended to be used as an allocator_ty...
Always enter the condition.
std::pair< iterator, bool > insert(const value_type &__x)
Attempts to insert a std::pair into the map.
ISO C++ entities toplevel namespace is std.
const _Tp & max(const _Tp &, const _Tp &)
This does what you think it does.
Base class for checking address and label information about allocations. Create a std::map between th...
Class with exception generation control. Intended to be used as a value_type in templatized code...
const _CharT * c_str() const noexcept
Return const pointer to null-terminated contents.
Always enter the condition.
A standard container made up of (key,value) pairs, which can be retrieved based on a key...
Primary class template hash.
Base class for incremental control and throw.
iterator find(const key_type &__x)
Tries to locate an element in a map.
Thown by exception safety machinery.
iterator begin() noexcept
GNU extensions for public use.
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.
_Tp * __addressof(_Tp &__r) noexcept
Same as C++11 std::addressof.
iterator erase(const_iterator __position)
Erases an element from a map.
Type throwing via random condition.
Allocator throwing via random condition.
mersenne_twister_engine< uint_fast32_t, 32, 624, 397, 31, 0x9908b0dfUL, 11, 0xffffffffUL, 7, 0x9d2c5680UL, 15, 0xefc60000UL, 18, 1812433253UL > mt19937
Never enter the condition.
Base class for random probability control and throw.
Struct holding two objects of arbitrary type.
Never enter the condition.
Allocator throwing via limit condition.
Type throwing via limit condition.
Uniform continuous distribution for random numbers.
basic_string< _CharT, _Traits, _Alloc > operator+(const basic_string< _CharT, _Traits, _Alloc > &__lhs, const basic_string< _CharT, _Traits, _Alloc > &__rhs)
Concatenate two strings.
auto end(_Container &__cont) -> decltype(__cont.end())
Return an iterator pointing to one past the last element of the container.
bool empty() const noexcept
Base struct for condition policy.