+2007-09-12 Benjamin Kosnik <bkoz@redhat.com>
+
+ * include/ext/pb_ds/*: Change namespace pb_ds to __gnu_pbds.
+ * docs/html/ext/pb_ds/*: Same.
+ * testsuite/ext/pb_ds/*: Same.
+ * testsuite/performance/ext/pb_ds/*: Same.
+ * testsuite/util/*: Same.
+
2007-09-12 Benjamin Kosnik <bkoz@redhat.com>
* include/parallel/find.h: Doxygen fixups.
<p>Additionally, a traits mechanism can be used to query a
container type for its attributes. Given any container
<tt>Cntnr</tt>, then <tt><a href=
- "assoc_container_traits.html">pb_ds::container_traits</a><Cntnr></tt>
+ "assoc_container_traits.html">__gnu_pbds::container_traits</a><Cntnr></tt>
is a traits class identifying the properties of the
container.</p>
<p>As mentioned in <a href=
"tutorial.html#pq">Tutorial::Priority Queues</a>,
<a href=
- "priority_queue.html"><tt>pb_ds::priority_queue</tt></a>
+ "priority_queue.html"><tt>__gnu_pbds::priority_queue</tt></a>
shares most of the same interface with <tt>std::priority_queue</tt>.
<i>E.g.</i> if <tt>q</tt> is a priority queue of type
<tt>Q</tt>, then <tt>q.top()</tt> will return the "largest"
value in the container (according to <tt><b>typename</b>
Q::cmp_fn</tt>). <a href=
- "priority_queue.html"><tt>pb_ds::priority_queue</tt></a>
+ "priority_queue.html"><tt>__gnu_pbds::priority_queue</tt></a>
has a larger (and very slightly different) interface than
<tt>std::priority_queue</tt>, however, since typically
<tt>push</tt> and <tt>pop</tt> are deemed insufficient for
<p>Tags and traits are very useful for manipulating generic
types. <a href=
- "priority_queue.html"><tt>pb_ds::priority_queue</tt></a>
+ "priority_queue.html"><tt>__gnu_pbds::priority_queue</tt></a>
publicly defines <tt>container_category</tt> as one of the tags
discussed in <a href="#pq_imp">Implementations</a>. Given any
container <tt>Cntnr</tt>, the tag of the underlying
<p>Additionally, a traits mechanism can be used to query a
container type for its attributes. Given any container
<tt>Cntnr</tt>, then <tt><a href=
- "assoc_container_traits.html">pb_ds::container_traits</a><Cntnr></tt>
+ "assoc_container_traits.html">__gnu_pbds::container_traits</a><Cntnr></tt>
is a traits class identifying the properties of the
container.</p>
<td>
<pre>
-<b>typename</b> pb_ds::detail::__conditional_type<
+<b>typename</b> __gnu_pbds::detail::__conditional_type<
<a href="#Reverse1686776"><tt>Reverse</tt></a>,
<b>typename</b> <a href=
"#String349403"><tt>String</tt></a>::const_reverse_iterator,
<td>
<pre>
-pb_ds::detail::null_node_metadata
+__gnu_pbds::detail::null_node_metadata
</pre>
</td>
#include <ext/pb_ds/detail/container_base_dispatch.hpp>
#include <ext/pb_ds/detail/basic_tree_policy/traits.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
#define PB_DS_BASE_C_DEC \
detail::container_base_dispatch<Key, Mapped, Tag, Policy_Tl, Allocator>::type
template<typename Key, typename Mapped, typename Cmp_Fn = std::less<Key>,
typename Tag = rb_tree_tag,
template<typename Const_Node_Iterator, typename Node_Iterator, typename Cmp_Fn_, typename Allocator_>
- class Node_Update = pb_ds::null_tree_node_update,
+ class Node_Update = __gnu_pbds::null_tree_node_update,
typename Allocator = std::allocator<char> >
class tree : public PB_DS_BASE_C_DEC
{
#undef PB_DS_BASE_C_DEC
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#ifndef PB_DS_TREE_LIKE_POLICY_BASE_HPP
#define PB_DS_TREE_LIKE_POLICY_BASE_HPP
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
#undef PB_DS_CLASS_C_DEC
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_TREE_LIKE_POLICY_BASE_HPP
#include <ext/pb_ds/detail/types_traits.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
struct null_node_metadata
{ };
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <ext/pb_ds/detail/tree_policy/node_metadata_selector.hpp>
#include <ext/pb_ds/detail/trie_policy/node_metadata_selector.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
struct trie_traits;
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#include <ext/pb_ds/detail/rb_tree_map_/traits.hpp>
#include <ext/pb_ds/detail/splay_tree_/traits.hpp>
#include <ext/pb_ds/tag_and_trait.hpp>
#include <ext/pb_ds/detail/type_utils.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
typedef integral_constant<int, is_simple<Key>::value> indicator;
};
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <functional>
#include <debug/debug.h>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
#undef PB_DS_V2S
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#include <ext/pb_ds/tag_and_trait.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
#undef PB_DS_TREE_NODE_ITERATOR_CLASS_C_DEC
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_BIN_SEARCH_TREE_NODE_ITERATORS_HPP
#include <ext/pb_ds/tag_and_trait.hpp>
#include <debug/debug.h>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
#undef PB_DS_TREE_ODIR_IT_C_DEC
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <ext/pb_ds/detail/bin_search_tree_/point_iterators.hpp>
#include <ext/pb_ds/detail/bin_search_tree_/node_iterators.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
node_update;
typedef
- pb_ds::null_tree_node_update<
+ __gnu_pbds::null_tree_node_update<
const_node_iterator,
node_iterator,
Cmp_Fn,
node_update;
typedef
- pb_ds::null_tree_node_update<
+ __gnu_pbds::null_tree_node_update<
const_node_iterator,
node_iterator,
Cmp_Fn,
};
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_BIN_SEARCH_TREE_NODE_AND_IT_TRAITS_HPP
#include <ext/pb_ds/detail/type_utils.hpp>
#include <debug/debug.h>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
entry_cmp<Value_Type, Cmp_Fn, is_simple<Value_Type>::value, Allocator>::type
#define PB_DS_RESIZE_POLICY_DEC \
- pb_ds::detail::resize_policy<typename Allocator::size_type>
+ __gnu_pbds::detail::resize_policy<typename Allocator::size_type>
/**
* class description = "Base class for some types of h3ap$">
#undef PB_DS_RESIZE_POLICY_DEC
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <ext/pb_ds/detail/binary_heap_/const_point_iterator.hpp>
#include <debug/debug.h>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
#undef PB_DS_CLASS_C_DEC
#undef PB_DS_BASE_C_DEC
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <ext/pb_ds/tag_and_trait.hpp>
#include <debug/debug.h>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
entry_pointer m_p_e;
};
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#ifndef PB_DS_BINARY_HEAP_ENTRY_CMP_HPP
#define PB_DS_BINARY_HEAP_ENTRY_CMP_HPP
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
};
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_BINARY_HEAP_ENTRY_CMP_HPP
#ifndef PB_DS_BINARY_HEAP_ENTRY_PRED_HPP
#define PB_DS_BINARY_HEAP_ENTRY_PRED_HPP
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
};
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_BINARY_HEAP_ENTRY_PRED_HPP
#include <debug/debug.h>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
#undef PB_DS_CLASS_C_DEC
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <ext/pb_ds/detail/type_utils.hpp>
#include <ext/pb_ds/detail/binomial_heap_base_/binomial_heap_base_.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
#undef PB_DS_BASE_C_DEC
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#include <ext/pb_ds/detail/left_child_next_sibling_heap_/left_child_next_sibling_heap_.hpp>
#include <ext/pb_ds/detail/left_child_next_sibling_heap_/null_metadata.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#endif
#include <debug/debug.h>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
enum
{
store_hash_ok = !Store_Hash
- || !is_same<Hash_Fn, pb_ds::null_hash_fn>::value
+ || !is_same<Hash_Fn, __gnu_pbds::null_hash_fn>::value
};
PB_DS_STATIC_ASSERT(sth, store_hash_ok);
#undef PB_DS_V2S
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
* Contains a conditional key destructor, used for exception handling.
*/
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
#undef PB_DS_CLASS_C_DEC
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#ifndef PB_DS_COND_DEALTOR_HPP
#define PB_DS_COND_DEALTOR_HPP
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_COND_DEALTOR_HPP
#include <ext/pb_ds/detail/pat_trie_/pat_trie_.hpp>
#undef PB_DS_DATA_FALSE_INDICATOR
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
at3t::value, at4t, at5t, at2t> type;
};
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <ext/throw_allocator.h>
#include <debug/debug.h>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
#undef PB_DS_CLASS_C_DEC
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <assert.h>
#include <ext/pb_ds/detail/types_traits.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
}
};
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_EQ_BY_LESS_HPP
#include <utility>
#include <debug/debug.h>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
#undef PB_DS_CLASS_C_DEC
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#endif
#include <debug/debug.h>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
enum
{
store_hash_ok = !Store_Hash
- || !is_same<Hash_Fn, pb_ds::null_hash_fn>::value
+ || !is_same<Hash_Fn, __gnu_pbds::null_hash_fn>::value
};
PB_DS_STATIC_ASSERT(sth, store_hash_ok);
#undef PB_DS_V2S
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#include <ext/pb_ds/linear_probe_fn.hpp>
#include <ext/pb_ds/quadratic_probe_fn.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
typedef
typename __conditional_type<
is_same<
- pb_ds::direct_mask_range_hashing<size_t>,
+ __gnu_pbds::direct_mask_range_hashing<size_t>,
Comb_Probe_Fn>::value,
- pb_ds::linear_probe_fn<size_type>,
- pb_ds::quadratic_probe_fn<size_type> >::__type
+ __gnu_pbds::linear_probe_fn<size_type>,
+ __gnu_pbds::quadratic_probe_fn<size_type> >::__type
type;
};
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#ifndef PB_DS_MASK_BASED_RANGE_HASHING_HPP
#define PB_DS_MASK_BASED_RANGE_HASHING_HPP
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
#undef PB_DS_CLASS_C_DEC
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#ifndef PB_DS_MOD_BASED_RANGE_HASHING_HPP
#define PB_DS_MOD_BASED_RANGE_HASHING_HPP
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_MOD_BASED_RANGE_HASHING_HPP
#include <functional>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
~probe_fn_base() { }
};
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <utility>
#include <debug/debug.h>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
#undef PB_DS_CLASS_C_DEC
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <utility>
#include <debug/debug.h>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
{ comb_probe_fn_base::swap(other); }
};
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <ext/pb_ds/detail/left_child_next_sibling_heap_/const_point_iterator.hpp>
#include <debug/debug.h>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
#undef PB_DS_BASE_C_DEC
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <ext/pb_ds/tag_and_trait.hpp>
#include <debug/debug.h>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
#undef PB_DS_CLASS_C_DEC
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#endif
#include <debug/debug.h>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
#undef PB_DS_CLASS_T_DEC
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <ext/pb_ds/detail/left_child_next_sibling_heap_/null_metadata.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
};
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_LEFT_CHILD_NEXT_SIBLING_HEAP_NODE_HPP
#include <ext/pb_ds/detail/left_child_next_sibling_heap_/null_metadata.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
{ };
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_LEFT_CHILD_NEXT_SIBLING_HEAP_NULL_METADATA_HPP
#ifndef PB_DS_LU_MAP_ENTRY_METADATA_BASE_HPP
#define PB_DS_LU_MAP_ENTRY_METADATA_BASE_HPP
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
struct lu_map_entry_metadata_base<null_lu_metadata>
{ };
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#endif
#include <debug/debug.h>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
#undef PB_DS_V2S
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
* Contains implementation of a lu counter policy's metadata.
*/
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
}
};
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#include <ext/pb_ds/detail/type_utils.hpp>
#include <debug/debug.h>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
#undef PB_DS_OV_TREE_CONST_NODE_ITERATOR_C_DEC
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <assert.h>
#include <debug/debug.h>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
#undef PB_DS_CONST_NODE_ITERATOR_NAME
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#include <ext/pb_ds/detail/ov_tree_map_/node_iterators.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
node_update;
typedef
- pb_ds::null_tree_node_update<
+ __gnu_pbds::null_tree_node_update<
const_node_iterator,
node_iterator,
Cmp_Fn,
node_update;
typedef
- pb_ds::null_tree_node_update<
+ __gnu_pbds::null_tree_node_update<
const_node_iterator,
node_iterator,
Cmp_Fn,
};
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_OV_TREE_NODE_AND_IT_TRAITS_HPP
#include <ext/pb_ds/detail/left_child_next_sibling_heap_/null_metadata.hpp>
#include <debug/debug.h>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
#undef PB_DS_BASE_C_DEC
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#include <ext/pb_ds/detail/pat_trie_/node_base.hpp>
#include <debug/debug.h>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
#undef PB_DS_BASE_C_DEC
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <debug/debug.h>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
#undef PB_DS_LEAF_C_DEC
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <debug/debug.h>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
#undef PB_DS_PAT_TRIE_SUBTREE_DEBUG_INFO_C_DEC
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <ext/pb_ds/detail/pat_trie_/node_metadata_base.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
#undef PB_DS_PAT_TRIE_SUBTREE_DEBUG_INFO_C_DEC
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <debug/debug.h>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
#undef PB_DS_PAT_TRIE_NODE_ITERATOR_C_DEC
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <ext/pb_ds/detail/basic_tree_policy/null_node_metadata.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
};
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_PAT_TRIE_NODE_BASE_HPP
#endif
#include <debug/debug.h>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
#undef PB_DS_V2S
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#include <debug/debug.h>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
#undef PB_DS_ODIR_IT_C_DEC
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
PB_DS_CLASS_T_DEC
inline void
PB_DS_CLASS_C_DEC::
-apply_update(node_pointer /*p_nd*/, pb_ds::null_node_update* /*p_update*/)
+apply_update(node_pointer /*p_nd*/, __gnu_pbds::null_node_update* /*p_update*/)
{ }
PB_DS_CLASS_T_DEC
PB_DS_CLASS_T_DEC
inline void
PB_DS_CLASS_C_DEC::
-update_to_top(node_pointer /*p_nd*/, pb_ds::null_node_update* /*p_update*/)
+update_to_top(node_pointer /*p_nd*/, __gnu_pbds::null_node_update* /*p_update*/)
{ }
#include <ext/pb_ds/detail/type_utils.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
#undef PB_DS_SYNTH_E_ACCESS_TRAITS_C_DEC
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <ext/pb_ds/detail/pat_trie_/node_iterators.hpp>
#include <ext/pb_ds/detail/pat_trie_/synth_e_access_traits.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
typedef E_Access_Traits e_access_traits;
typedef
- pb_ds::detail::synth_e_access_traits<
+ __gnu_pbds::detail::synth_e_access_traits<
type_traits,
false,
e_access_traits>
node_update;
typedef
- pb_ds::null_trie_node_update<
+ __gnu_pbds::null_trie_node_update<
const_node_iterator,
node_iterator,
E_Access_Traits,
typedef E_Access_Traits e_access_traits;
typedef
- pb_ds::detail::synth_e_access_traits<
+ __gnu_pbds::detail::synth_e_access_traits<
type_traits,
true,
e_access_traits>
node_update;
typedef
- pb_ds::null_trie_node_update<
+ __gnu_pbds::null_trie_node_update<
const_node_iterator,
const_node_iterator,
E_Access_Traits,
};
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_PAT_TRIE_NODE_AND_IT_TRAITS_HPP
#include <ext/pb_ds/detail/binary_heap_/binary_heap_.hpp>
#include <ext/pb_ds/detail/thin_heap_/thin_heap_.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
};
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_PRIORITY_QUEUE_BASE_DS_DISPATCHER_HPP
#include <ext/pb_ds/detail/basic_tree_policy/null_node_metadata.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
bool m_red;
};
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <assert.h>
#include <debug/debug.h>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
#undef PB_DS_V2S
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#include <ext/pb_ds/detail/rb_tree_map_/node.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
{ };
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#ifndef PB_DS_RC_HPP
#define PB_DS_RC_HPP
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
#undef PB_DS_CLASS_C_DEC
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <ext/pb_ds/detail/rc_binomial_heap_/rc.hpp>
#include <debug/debug.h>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
#undef PB_DS_RC_C_DEC
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#ifndef PB_DS_HASH_LOAD_CHECK_RESIZE_TRIGGER_SIZE_BASE_HPP
#define PB_DS_HASH_LOAD_CHECK_RESIZE_TRIGGER_SIZE_BASE_HPP
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
set_size(size_type size) { }
};
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
do_resize(size_type new_size);
};
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#ifndef PB_DS_SPLAY_TREE_NODE_HPP
#define PB_DS_SPLAY_TREE_NODE_HPP
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
bool m_special;
};
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <assert.h>
#include <debug/debug.h>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
#undef PB_DS_EP2VP
#undef PB_DS_V2S
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#include <ext/pb_ds/detail/splay_tree_/node.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
{ };
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_SPLAY_TREE_NODE_AND_IT_TRAITS_HPP
#include <ext/pb_ds/tag_and_trait.hpp>
#include <ext/hash_map>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
struct default_comb_hash_fn
{
- typedef pb_ds::direct_mask_range_hashing<> type;
+ typedef __gnu_pbds::direct_mask_range_hashing<> type;
};
template<typename Comb_Hash_Fn>
typedef
typename __conditional_type<
is_same<
- pb_ds::direct_mask_range_hashing<
+ __gnu_pbds::direct_mask_range_hashing<
size_type>,
Comb_Hash_Fn>::value,
- pb_ds::hash_exponential_size_policy<
+ __gnu_pbds::hash_exponential_size_policy<
size_type>,
- pb_ds::hash_prime_size_policy>::__type
+ __gnu_pbds::hash_prime_size_policy>::__type
size_policy_type;
public:
typedef
- pb_ds::hash_standard_resize_policy<
+ __gnu_pbds::hash_standard_resize_policy<
size_policy_type,
- pb_ds::hash_load_check_resize_trigger<
+ __gnu_pbds::hash_load_check_resize_trigger<
false,
size_type>,
false,
struct default_update_policy
{
- typedef pb_ds::move_to_front_lu_policy<> type;
+ typedef __gnu_pbds::move_to_front_lu_policy<> type;
};
template<typename Comb_Probe_Fn>
typedef
typename __conditional_type<
is_same<
- pb_ds::direct_mask_range_hashing<size_t>,
+ __gnu_pbds::direct_mask_range_hashing<size_t>,
Comb_Probe_Fn>::value,
- pb_ds::linear_probe_fn<
+ __gnu_pbds::linear_probe_fn<
size_type>,
- pb_ds::quadratic_probe_fn<
+ __gnu_pbds::quadratic_probe_fn<
size_type> >::__type
type;
};
char> > >
{
typedef
- pb_ds::string_trie_e_access_traits<
+ __gnu_pbds::string_trie_e_access_traits<
std::basic_string<
Char,
Char_Traits,
};
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_STANDARD_POLICIES_HPP
#include <ext/pb_ds/detail/left_child_next_sibling_heap_/null_metadata.hpp>
#include <debug/debug.h>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
#undef PB_DS_BASE_C_DEC
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <ext/pb_ds/detail/basic_tree_policy/null_node_metadata.hpp>
#include <ext/pb_ds/detail/types_traits.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
};
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_TREE_NODE_METADATA_SELECTOR_HPP
#include <ext/pb_ds/detail/basic_tree_policy/basic_tree_policy_base.hpp>
#include <ext/pb_ds/detail/basic_tree_policy/null_node_metadata.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifdef PB_DS_TREE_TRACE
#include <ext/pb_ds/detail/basic_tree_policy/null_node_metadata.hpp>
#include <ext/pb_ds/detail/types_traits.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
};
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_TRIE_NODE_METADATA_SELECTOR_HPP
#include <ext/pb_ds/detail/basic_tree_policy/basic_tree_policy_base.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
#undef PB_DS_BASE_C_DEC
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_TRIE_POLICY_BASE_HPP
#include <ext/type_traits.h>
#include <ext/numeric_traits.h>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
};
#define PB_DS_STATIC_ASSERT(UNIQUE, E) \
- typedef pb_ds::detail::__static_assert_dumclass<sizeof(pb_ds::detail::__static_assert<bool(E)>)> UNIQUE##__static_assert_type
+ typedef __gnu_pbds::detail::__static_assert_dumclass<sizeof(__gnu_pbds::detail::__static_assert<bool(E)>)> UNIQUE##__static_assert_type
#endif
typedef Type type;
};
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <ext/pb_ds/detail/type_utils.hpp>
#include <utility>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace detail
{
no_throw_copies m_no_throw_copies_indicator;
};
} // namespace detail
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <stdexcept>
#include <cstdlib>
-namespace pb_ds
+namespace __gnu_pbds
{
// Base class for exceptions.
struct container_error : public std::logic_error
{
container_error()
- : std::logic_error(__N("pb_ds::container_error")) { }
+ : std::logic_error(__N("__gnu_pbds::container_error")) { }
};
// An entry cannot be inserted into a container object for logical
__throw_resize_error(void)
{ std::abort(); }
#endif
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <ext/pb_ds/detail/hash_fn/mod_based_range_hashing.hpp>
#include <ext/pb_ds/detail/resize_policy/hash_load_check_resize_trigger_size_base.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
// A null hash function, indicating that the combining hash function
// is actually a ranged hash function.
#undef PB_DS_CLASS_T_DEC
#undef PB_DS_CLASS_C_DEC
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <cstdlib>
#include <ext/pb_ds/detail/list_update_policy/counter_lu_metadata.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
// A null type that means that each link in a list-based container
// does not actually need metadata.
#undef PB_DS_CLASS_T_DEC
#undef PB_DS_CLASS_C_DEC
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <ext/pb_ds/detail/priority_queue_base_dispatch.hpp>
#include <ext/pb_ds/detail/standard_policies.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
// A priority queue.
template<typename Value_Type,
swap(priority_queue& other)
{ base_type::swap(other); }
};
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <ext/pb_ds/detail/type_utils.hpp>
/**
- * @namespace pb_ds
+ * @namespace __gnu_pbds
* @brief GNU extension policy-based data structures for public use.
*/
-namespace pb_ds
+namespace __gnu_pbds
{
// A trivial iterator tag. Signifies that the iterators has none of
// the STL's movement abilities.
reverse_iteration = base_type::reverse_iteration
};
};
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <ext/pb_ds/detail/type_utils.hpp>
#include <ext/pb_ds/detail/basic_tree_policy/basic_tree_policy_base.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
// A null node updator, indicating that no node updates are required.
template<typename Const_Node_Iterator,
#undef PB_DS_CLASS_C_DEC
#undef PB_DS_BASE_C_DEC
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <ext/pb_ds/detail/type_utils.hpp>
#include <ext/pb_ds/detail/trie_policy/trie_policy_base.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
// A null node updator, indicating that no node updates are required.
template<typename Const_Node_Iterator,
#undef PB_DS_CLASS_C_DEC
#undef PB_DS_BASE_C_DEC
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <ext/pb_ds/tag_and_trait.hpp>
using namespace std;
-using namespace pb_ds;
-using namespace pb_ds;
+using namespace __gnu_pbds;
template<class DS_Category>
void
#include <ext/pb_ds/assoc_container.hpp>
using namespace std;
-using namespace pb_ds;
-using namespace pb_ds;
+using namespace __gnu_pbds;
// The following function performs a sequence of operations on an
// associative container object mapping integers to characters.
#include <ext/pb_ds/assoc_container.hpp>
using namespace std;
-using namespace pb_ds;
+using namespace __gnu_pbds;
// A simple hash functor.
// hash could serve instead of this functor, but it is not yet
#include <ext/pb_ds/assoc_container.hpp>
using namespace std;
-using namespace pb_ds;
+using namespace __gnu_pbds;
// A simple priority queue that also supports an "contains" query.
class contains_pq
#include <ext/pb_ds/priority_queue.hpp>
using namespace std;
-using namespace pb_ds;
-using namespace pb_ds;
+using namespace __gnu_pbds;
// The following function performs a sequence of operations on a
// priority queue object storing integers.
{
// Perform operations on a pairing-heap queue.
cout << "Pairing heap" << endl;
- pb_ds::priority_queue<int, less<int>, pairing_heap_tag> c;
+ __gnu_pbds::priority_queue<int, less<int>, pairing_heap_tag> c;
some_op_sequence(c);
}
{
// Perform operations on a binomial-heap queue.
cout << "Binomial heap" << endl;
- pb_ds::priority_queue<int, less<int>, binomial_heap_tag> c;
+ __gnu_pbds::priority_queue<int, less<int>, binomial_heap_tag> c;
some_op_sequence(c);
}
{
// Perform operations on a binomial-heap queue.
cout << "Redundant-counter binomial heap" << endl;
- pb_ds::priority_queue<int, less<int>, rc_binomial_heap_tag> c;
+ __gnu_pbds::priority_queue<int, less<int>, rc_binomial_heap_tag> c;
some_op_sequence(c);
}
{
// Perform operations on a binomial-heap queue.
cout << "Binary heap" << endl;
- pb_ds::priority_queue<int, less<int>, binary_heap_tag> c;
+ __gnu_pbds::priority_queue<int, less<int>, binary_heap_tag> c;
some_op_sequence(c);
}
{
// Perform operations on a thin-heap queue.
cout << "Thin heap" << endl;
- pb_ds::priority_queue<int, less<int>, thin_heap_tag> c;
+ __gnu_pbds::priority_queue<int, less<int>, thin_heap_tag> c;
some_op_sequence(c);
}
#include <ext/pb_ds/tag_and_trait.hpp>
using namespace std;
-using namespace pb_ds;
-using namespace pb_ds;
+using namespace __gnu_pbds;
// The following function performs a sequence of operations on an
// associative container object storing integers.
#include <ext/pb_ds/assoc_container.hpp>
using namespace std;
-using namespace pb_ds;
-using namespace pb_ds;
+using namespace __gnu_pbds;
// The following functor takes a map's value-type object and returns
// whether its key is between two numbers.
#include <ext/pb_ds/assoc_container.hpp>
using namespace std;
-using namespace pb_ds;
+using namespace __gnu_pbds;
int main()
{
#include <cassert>
using namespace std;
-using namespace pb_ds;
+using namespace __gnu_pbds;
// A simple hash functor.
// hash could serve instead of this functor, but it is not yet
{
g.resize(200);
}
- catch(pb_ds::resize_error& )
+ catch(__gnu_pbds::resize_error& )
{
ex_thrown = true;
}
#include <ext/pb_ds/hash_policy.hpp>
using namespace std;
-using namespace pb_ds;
+using namespace __gnu_pbds;
// A simple hash functor.
// hash could serve instead of this functor, but it is not yet
#include <ext/pb_ds/hash_policy.hpp>
using namespace std;
-using namespace pb_ds;
+using namespace __gnu_pbds;
// A simple hash functor.
// hash could serve instead of this functor, but it is not yet
#include <ext/pb_ds/hash_policy.hpp>
using namespace std;
-using namespace pb_ds;
+using namespace __gnu_pbds;
// A simple hash functor.
// hash could serve instead of this functor, but it is not yet
#include <ext/pb_ds/hash_policy.hpp>
using namespace std;
-using namespace pb_ds;
+using namespace __gnu_pbds;
// A simple hash functor.
// hash could serve instead of this functor, but it is not yet
#include <ext/pb_ds/assoc_container.hpp>
using namespace std;
-using namespace pb_ds;
+using namespace __gnu_pbds;
int main()
{
#include <ext/pb_ds/hash_policy.hpp>
using namespace std;
-using namespace pb_ds;
+using namespace __gnu_pbds;
// A simple hash functor. hash could serve instead of this functor,
// but it is not yet standard everywhere.
#include <ext/pb_ds/tag_and_trait.hpp>
using namespace std;
-using namespace pb_ds;
-using namespace pb_ds;
+using namespace __gnu_pbds;
template<class DS_Category>
void
{
// Print the attributes of a binary heap.
typedef
- pb_ds::priority_queue<
+ __gnu_pbds::priority_queue<
int,
std::less<int>,
binary_heap_tag>
{
// Print the attributes of a binomial heap.
typedef
- pb_ds::priority_queue<
+ __gnu_pbds::priority_queue<
int,
std::less<int>,
binomial_heap_tag>
{
// Print the attributes of a redundant-counter binomial heap.
typedef
- pb_ds::priority_queue<
+ __gnu_pbds::priority_queue<
int,
std::less<int>,
rc_binomial_heap_tag>
{
// Print the attributes of a pairing heap.
typedef
- pb_ds::priority_queue<
+ __gnu_pbds::priority_queue<
int,
std::less<int>,
pairing_heap_tag>
*/
typedef
- pb_ds::priority_queue<
+ __gnu_pbds::priority_queue<
int,
std::less<int>,
thin_heap_tag>
#include <ext/pb_ds/priority_queue.hpp>
using namespace std;
-using namespace pb_ds;
-using namespace pb_ds;
+using namespace __gnu_pbds;
// The value type of the priority queue.
// The first entry is the node's id, and the second is the distance.
};
// The priority queue type.
- typedef pb_ds::priority_queue< pq_value, pq_value_cmp> pq_t;
+ typedef __gnu_pbds::priority_queue< pq_value, pq_value_cmp> pq_t;
// The priority queue object.
pq_t p;
#include <ext/pb_ds/priority_queue.hpp>
using namespace std;
-using namespace pb_ds;
-using namespace pb_ds;
+using namespace __gnu_pbds;
int
main()
{
- pb_ds::priority_queue<int> p;
+ __gnu_pbds::priority_queue<int> p;
// First we insert some values into the container.
for (int i = 0; i < 1000; ++i)
#include <ext/pb_ds/priority_queue.hpp>
using namespace std;
-using namespace pb_ds;
-using namespace pb_ds;
+using namespace __gnu_pbds;
int
main()
{
// Two priority queue objects.
- pb_ds::priority_queue<int> even_p, odd_p;
+ __gnu_pbds::priority_queue<int> even_p, odd_p;
// First we insert some values: even ones into even_p, and odd ones
// into odd_p.
// Print out the values.
cout << "Initial values in even priority queue:" << endl;
- pb_ds::priority_queue<int>::const_iterator it;
+ __gnu_pbds::priority_queue<int>::const_iterator it;
for (it = even_p.begin(); it != even_p.end(); ++it)
cout <<* it << endl;
#include <ext/pb_ds/assoc_container.hpp>
using namespace std;
-using namespace pb_ds;
-using namespace pb_ds;
+using namespace __gnu_pbds;
// A priority queue of integers, which supports fast pushes,
// duplicated-int avoidance, and arbitrary-int erases.
private:
// A priority queue of strings.
- typedef pb_ds::priority_queue< int> pq_t;
+ typedef __gnu_pbds::priority_queue< int> pq_t;
// A hash-table mapping strings to point_iterators inside the
// priority queue.
#include <ext/pb_ds/hash_policy.hpp>
using namespace std;
-using namespace pb_ds;
-using namespace pb_ds;
+using namespace __gnu_pbds;
/**
* A (somewhat simplistic) ranged-hash function for strings.
#include <ext/pb_ds/hash_policy.hpp>
using namespace std;
-using namespace pb_ds;
+using namespace __gnu_pbds;
// A string hash functor.
struct string_hash : public unary_function<string, size_t>
#include <ext/pb_ds/assoc_container.hpp>
using namespace std;
-using namespace pb_ds;
-using namespace pb_ds;
+using namespace __gnu_pbds;
// Following are definitions of line intervals and functors operating
// on them. As the purpose of this example is node invariants, and not
#include <cassert>
using namespace std;
-using namespace pb_ds;
-using namespace pb_ds;
+using namespace __gnu_pbds;
+using namespace __gnu_pbds;
int main()
{
*
*/
// A splay tree table mapping ints to chars.
- typedef
- tree<
- int,
- char,
- less<
- int>,
- splay_tree_tag>
- map_t;
+ typedef tree<int, char, less<int>, splay_tree_tag> map_t;
// Two map_t object.
map_t h0, h1;
{
h2.join(h3);
}
- catch (pb_ds::join_error& )
+ catch (__gnu_pbds::join_error& )
{
exception_thrown = true;
}
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
-using namespace pb_ds;
-using namespace pb_ds;
+using namespace __gnu_pbds;
// A red-black tree table storing ints and their order
// statistics. Note that since the tree uses
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
-using namespace pb_ds;
-using namespace pb_ds;
+using namespace __gnu_pbds;
// A splay tree table mapping ints to chars and storing the ints order
// statistics.
typedef
-tree<
- int,
- char,
- less<int>,
- splay_tree_tag,
- tree_order_statistics_node_update>
+tree<int, char, less<int>,
+ splay_tree_tag,
+ tree_order_statistics_node_update>
tree_map_t;
int main()
#include <ext/pb_ds/trie_policy.hpp>
using namespace std;
-using namespace pb_ds;
+using namespace __gnu_pbds;
// DNA is represented by a string.
typedef string dna_t;
#include <ext/pb_ds/tag_and_trait.hpp>
using namespace std;
-using namespace pb_ds;
-using namespace pb_ds;
+using namespace __gnu_pbds;
// A PATRICIA trie with a prefix-search node-updator type. Note that
// since the node updator is trie_prefix_search_node_update, then the
#include <ext/pb_ds/assoc_container.hpp>
using namespace std;
-using namespace pb_ds;
+using namespace __gnu_pbds;
int main()
{
#include <cassert>
using namespace std;
-using namespace pb_ds;
+using namespace __gnu_pbds;
/**
* The following function performs a sequence of operations on an
int
main(int argc, char* a_p_argv[])
{
- using namespace pb_ds::test;
+ using namespace __gnu_pbds::test;
typedef hash_map_tl_t map_tl_t;
return rand_regression_test(ITERATIONS, KEYS,
int
main(int argc, char* a_p_argv[])
{
- using namespace pb_ds::test;
+ using namespace __gnu_pbds::test;
typedef hash_set_tl_t map_tl_t;
return rand_regression_test(ITERATIONS, KEYS,
int
main(int argc, char* a_p_argv[])
{
- using namespace pb_ds::test;
+ using namespace __gnu_pbds::test;
typedef lu_map_tl_t map_tl_t;
return rand_regression_test(50, 10,
int
main(int argc, char* a_p_argv[])
{
- using namespace pb_ds::test;
+ using namespace __gnu_pbds::test;
typedef lu_set_tl_t map_tl_t;
return rand_regression_test(50, 10,
int
main(int argc, char* a_p_argv[])
{
- using namespace pb_ds::test;
+ using namespace __gnu_pbds::test;
return rand_regression_test(ITERATIONS, KEYS,
"tree_no_data_map_rand_regression_test",
pq_tl_t());
#include <cassert>
using namespace std;
-using namespace pb_ds;
-using namespace pb_ds;
+using namespace __gnu_pbds;
+using namespace __gnu_pbds;
template<typename Cntnr>
void
* Perform operations on a pairing-heap queue.
*/
cout << "Pairing heap" << endl;
- pb_ds::priority_queue<int, less<int>, pairing_heap_tag> c;
+ __gnu_pbds::priority_queue<int, less<int>, pairing_heap_tag> c;
some_op_sequence(c);
}
* Perform operations on a binomial-heap queue.
*/
cout << "Binomial heap" << endl;
- pb_ds::priority_queue<int, less<int>, binomial_heap_tag> c;
+ __gnu_pbds::priority_queue<int, less<int>, binomial_heap_tag> c;
some_op_sequence(c);
}
* Perform operations on a binomial-heap queue.
*/
cout << "Redundant-counter binomial heap" << endl;
- pb_ds::priority_queue<int, less<int>, rc_binomial_heap_tag> c;
+ __gnu_pbds::priority_queue<int, less<int>, rc_binomial_heap_tag> c;
some_op_sequence(c);
}
* Perform operations on a binomial-heap queue.
*/
cout << "Binary heap" << endl;
- pb_ds::priority_queue<int, less<int>, binary_heap_tag> c;
+ __gnu_pbds::priority_queue<int, less<int>, binary_heap_tag> c;
some_op_sequence(c);
}
* Perform operations on a thin-heap queue.
*/
cout << "Thin heap" << endl;
- pb_ds::priority_queue<int, less<int>, thin_heap_tag> c;
+ __gnu_pbds::priority_queue<int, less<int>, thin_heap_tag> c;
some_op_sequence(c);
}
}
* Perform operations on a pairing-heap queue.
*/
cout << "Pairing heap" << endl;
- pb_ds::priority_queue<int, less<int>, pairing_heap_tag> c;
+ __gnu_pbds::priority_queue<int, less<int>, pairing_heap_tag> c;
some_op_sequence(c);
}
* Perform operations on a binomial-heap queue.
*/
cout << "Binomial heap" << endl;
- pb_ds::priority_queue<int, less<int>, binomial_heap_tag> c;
+ __gnu_pbds::priority_queue<int, less<int>, binomial_heap_tag> c;
some_op_sequence(c);
}
* Perform operations on a binomial-heap queue.
*/
cout << "Redundant-counter binomial heap" << endl;
- pb_ds::priority_queue<int, less<int>, rc_binomial_heap_tag> c;
+ __gnu_pbds::priority_queue<int, less<int>, rc_binomial_heap_tag> c;
some_op_sequence(c);
}
* Perform operations on a binomial-heap queue.
*/
cout << "Binary heap" << endl;
- pb_ds::priority_queue<int, less<int>, binary_heap_tag> c;
+ __gnu_pbds::priority_queue<int, less<int>, binary_heap_tag> c;
some_op_sequence(c);
}
* Perform operations on a thin-heap queue.
*/
cout << "Thin heap" << endl;
- pb_ds::priority_queue<int, less<int>, thin_heap_tag> c;
+ __gnu_pbds::priority_queue<int, less<int>, thin_heap_tag> c;
some_op_sequence(c);
}
}
int
main(int argc, char* a_p_argv[])
{
- using namespace pb_ds::test;
+ using namespace __gnu_pbds::test;
typedef tree_map_tl_t map_tl_t;
return rand_regression_test(ITERATIONS, KEYS,
int
main(int argc, char* a_p_argv[])
{
- using namespace pb_ds::test;
+ using namespace __gnu_pbds::test;
typedef tree_set_tl_t map_tl_t;
return rand_regression_test(ITERATIONS, KEYS,
int
main(int argc, char* a_p_argv[])
{
- using namespace pb_ds::test;
+ using namespace __gnu_pbds::test;
typedef trie_map_tl_t map_tl_t;
return rand_regression_test(ITERATIONS, KEYS,
int
main(int argc, char* a_p_argv[])
{
- using namespace pb_ds::test;
+ using namespace __gnu_pbds::test;
typedef trie_set_tl_t map_tl_t;
return rand_regression_test(ITERATIONS, KEYS,
int
main(int argc, char* a_p_argv[])
{
- using namespace pb_ds::test;
+ using namespace __gnu_pbds::test;
size_t vn = 200;
size_t vs = 200;
erase_test<vec_t::const_iterator> tst(b, vn, vs, vm);
typedef __gnu_test::tracker_allocator<char> alloc_t;
{
- typedef hash_common_types<int, pb_ds::null_mapped_type, int_hash, std::equal_to<int>, alloc_t>::performance_tl tl_t;
+ typedef hash_common_types<int, __gnu_pbds::null_mapped_type, int_hash, std::equal_to<int>, alloc_t>::performance_tl tl_t;
tl_t tl;
__gnu_cxx::typelist::apply(tst, tl);
int
main(int argc, char* a_p_argv[])
{
- using namespace pb_ds::test;
+ using namespace __gnu_pbds::test;
size_t vn = 200;
size_t vs = 200;
int
main(int argc, char* a_p_argv[])
{
- using namespace pb_ds::test;
+ using namespace __gnu_pbds::test;
std::string f_name = "thirty_years_among_the_dead_preproc.txt";
size_t prm;
int
main(int argc, char* a_p_argv[])
{
- using namespace pb_ds::test;
+ using namespace __gnu_pbds::test;
std::string f_name = "thirty_years_among_the_dead_preproc.txt";
size_t prm;
int
main(int argc, char* a_p_argv[])
{
- using namespace pb_ds::test;
+ using namespace __gnu_pbds::test;
std::string f_name = "thirty_years_among_the_dead_preproc.txt";
size_t prm;
int
main(int argc, char* a_p_argv[])
{
- using namespace pb_ds::test;
+ using namespace __gnu_pbds::test;
size_t vn = 200;
size_t vs = 200;
int
main(int argc, char* a_p_argv[])
{
- using namespace pb_ds::test;
+ using namespace __gnu_pbds::test;
size_t vn = 200;
size_t vs = 200;
int
main(int argc, char* a_p_argv[])
{
- using namespace pb_ds::test;
+ using namespace __gnu_pbds::test;
std::string f_name = "thirty_years_among_the_dead_preproc.txt";
size_t vn = 200;
int
main(int argc, char* a_p_argv[])
{
- using namespace pb_ds::test;
+ using namespace __gnu_pbds::test;
std::string f_name = "thirty_years_among_the_dead_preproc.txt";
size_t vn = 100;
int
main(int argc, char* a_p_argv[])
{
- using namespace pb_ds::test;
+ using namespace __gnu_pbds::test;
std::string f_name = "thirty_years_among_the_dead_preproc.txt";
size_t vn = 200;
int
main(int argc, char* a_p_argv[])
{
- using namespace pb_ds::test;
+ using namespace __gnu_pbds::test;
std::string f_name = "thirty_years_among_the_dead_preproc.txt";
size_t vn = 200;
size_t vs = 200;
int
main(int argc, char* a_p_argv[])
{
- using namespace pb_ds::test;
+ using namespace __gnu_pbds::test;
std::string f_name = "thirty_years_among_the_dead_preproc.txt";
size_t vn = 200;
size_t vs = 200;
int
main(int argc, char* a_p_argv[])
{
- using namespace pb_ds::test;
+ using namespace __gnu_pbds::test;
size_t vn = 200;
size_t vs = 200;
int
main(int argc, char* a_p_argv[])
{
- using namespace pb_ds::test;
+ using namespace __gnu_pbds::test;
size_t vn = 200;
size_t vs = 200;
int
main(int argc, char* a_p_argv[])
{
- using namespace pb_ds::test;
+ using namespace __gnu_pbds::test;
size_t vn = 200;
size_t vs = 200;
size_t vm = 2100;
int
main(int argc, char* a_p_argv[])
{
- using namespace pb_ds::test;
+ using namespace __gnu_pbds::test;
std::string f_name = "thirty_years_among_the_dead_preproc.txt";
size_t vn = 200;
size_t vs = 200;
int
main(int argc, char* a_p_argv[])
{
- using namespace pb_ds::test;
+ using namespace __gnu_pbds::test;
size_t vn = 200;
size_t vs = 200;
size_t vm = 2100;
{
typedef tree_order_statistics_test< true> test_t;
test_t tst(vn, vs, vm);
- typedef tree_common_types<int, pb_ds::null_mapped_type, std::less<int>, pb_ds::tree_order_statistics_node_update>::performance_tl tl_t;
+ typedef tree_common_types<int, __gnu_pbds::null_mapped_type, std::less<int>, __gnu_pbds::tree_order_statistics_node_update>::performance_tl tl_t;
tl_t tl;
__gnu_cxx::typelist::apply(tst, tl);
}
int
main(int argc, char* a_p_argv[])
{
- using namespace pb_ds::test;
+ using namespace __gnu_pbds::test;
size_t vn = 200;
size_t vs = 200;
size_t vm = 2100;
typedef tree_split_join_test<true> test_t;
test_t tst(vn, vs, vm);
- typedef tree_common_types<int, pb_ds::null_mapped_type>::performance_tl tl_t;
+ typedef tree_common_types<int, __gnu_pbds::null_mapped_type>::performance_tl tl_t;
tl_t tl;
__gnu_cxx::typelist::apply(tst, tl);
}
int
main(int argc, char* a_p_argv[])
{
- using namespace pb_ds::test;
+ using namespace __gnu_pbds::test;
std::string f_name = "thirty_years_among_the_dead_preproc.txt";
size_t vn = 200;
int
main(int argc, char* a_p_argv[])
{
- using namespace pb_ds::test;
+ using namespace __gnu_pbds::test;
std::string f_name = "thirty_years_among_the_dead_preproc.txt";
size_t vn = 200;
#include <common_type/assoc/template_policy.hpp>
#include <ext/pb_ds/assoc_container.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
template<typename Key,
typename Data,
- class Hash_Fn = typename pb_ds::detail::default_hash_fn<Key>::type,
+ class Hash_Fn = typename __gnu_pbds::detail::default_hash_fn<Key>::type,
class Eq_Fn = std::equal_to<Key>,
class Allocator = std::allocator<std::pair<const Key, Data> > >
struct hash_common_types
typedef typename Allocator::size_type size_type;
typedef
- pb_ds::test::hash_load_check_resize_trigger_t_<
+ __gnu_pbds::test::hash_load_check_resize_trigger_t_<
Allocator,
1, 8,
1, 2,
no_access_half_load_check_resize_trigger_policy;
typedef
- pb_ds::test::hash_load_check_resize_trigger_t_<
+ __gnu_pbds::test::hash_load_check_resize_trigger_t_<
Allocator,
1, 8,
1, 2,
access_half_load_check_resize_trigger_policy;
typedef
- pb_ds::test::hash_load_check_resize_trigger_t_<
+ __gnu_pbds::test::hash_load_check_resize_trigger_t_<
Allocator,
1, 8,
1, 1,
no_access_one_load_check_resize_trigger_policy;
typedef
- pb_ds::test::cc_hash_max_collision_check_resize_trigger_t_<
+ __gnu_pbds::test::cc_hash_max_collision_check_resize_trigger_t_<
Allocator,
1, 2,
false>
no_access_half_max_col_check_check_resize_trigger_policy;
typedef
- pb_ds::test::cc_hash_max_collision_check_resize_trigger_t_<
+ __gnu_pbds::test::cc_hash_max_collision_check_resize_trigger_t_<
Allocator,
1, 2,
true>
access_half_max_col_check_check_resize_trigger_policy;
- typedef pb_ds::test::linear_probe_fn_t_<Key, Allocator> lin_p_t;
+ typedef __gnu_pbds::test::linear_probe_fn_t_<Key, Allocator> lin_p_t;
- typedef pb_ds::test::quadratic_probe_fn_t_<Key, Allocator> quad_p_t;
+ typedef __gnu_pbds::test::quadratic_probe_fn_t_<Key, Allocator> quad_p_t;
typedef
typename __gnu_cxx::typelist::create4<
- pb_ds::detail::false_type,
- pb_ds::test::direct_mask_range_hashing_t_<
+ __gnu_pbds::detail::false_type,
+ __gnu_pbds::test::direct_mask_range_hashing_t_<
Allocator>,
no_access_half_load_check_resize_trigger_policy,
- pb_ds::test::hash_exponential_size_policy_t_<
+ __gnu_pbds::test::hash_exponential_size_policy_t_<
Allocator> >::type
performance_cc_policy0;
typedef
typename __gnu_cxx::typelist::create4<
- pb_ds::detail::false_type,
- pb_ds::test::direct_mod_range_hashing_t_<
+ __gnu_pbds::detail::false_type,
+ __gnu_pbds::test::direct_mod_range_hashing_t_<
Allocator>,
no_access_half_load_check_resize_trigger_policy,
- pb_ds::test::hash_prime_size_policy_t_>::type
+ __gnu_pbds::test::hash_prime_size_policy_t_>::type
performance_cc_policy1;
typedef
typename __gnu_cxx::typelist::create4<
- pb_ds::detail::false_type,
- pb_ds::test::direct_mask_range_hashing_t_<
+ __gnu_pbds::detail::false_type,
+ __gnu_pbds::test::direct_mask_range_hashing_t_<
Allocator>,
no_access_one_load_check_resize_trigger_policy,
- pb_ds::test::hash_exponential_size_policy_t_<
+ __gnu_pbds::test::hash_exponential_size_policy_t_<
Allocator> >::type
performance_cc_policy2;
typedef
typename __gnu_cxx::typelist::create4<
- pb_ds::detail::false_type,
- pb_ds::test::direct_mod_range_hashing_t_<
+ __gnu_pbds::detail::false_type,
+ __gnu_pbds::test::direct_mod_range_hashing_t_<
Allocator>,
no_access_one_load_check_resize_trigger_policy,
- pb_ds::test::hash_prime_size_policy_t_ >::type
+ __gnu_pbds::test::hash_prime_size_policy_t_ >::type
performance_cc_policy3;
typedef
typename __gnu_cxx::typelist::create4<
- pb_ds::detail::true_type,
- pb_ds::test::direct_mask_range_hashing_t_<
+ __gnu_pbds::detail::true_type,
+ __gnu_pbds::test::direct_mask_range_hashing_t_<
Allocator>,
no_access_half_load_check_resize_trigger_policy,
- pb_ds::test::hash_exponential_size_policy_t_<
+ __gnu_pbds::test::hash_exponential_size_policy_t_<
Allocator> >::type
performance_cc_policy4;
typedef
typename __gnu_cxx::typelist::create4<
- pb_ds::detail::false_type,
- pb_ds::test::direct_mask_range_hashing_t_<
+ __gnu_pbds::detail::false_type,
+ __gnu_pbds::test::direct_mask_range_hashing_t_<
Allocator>,
no_access_half_max_col_check_check_resize_trigger_policy,
- pb_ds::test::hash_exponential_size_policy_t_<
+ __gnu_pbds::test::hash_exponential_size_policy_t_<
Allocator> >::type
performance_cc_policy5;
typedef
typename __gnu_cxx::typelist::create4<
- pb_ds::detail::false_type,
- pb_ds::test::direct_mask_range_hashing_t_<
+ __gnu_pbds::detail::false_type,
+ __gnu_pbds::test::direct_mask_range_hashing_t_<
Allocator>,
access_half_max_col_check_check_resize_trigger_policy,
- pb_ds::test::hash_exponential_size_policy_t_<
+ __gnu_pbds::test::hash_exponential_size_policy_t_<
Allocator> >::type
regression_cc_policy0;
typedef
typename __gnu_cxx::typelist::create4<
- pb_ds::detail::false_type,
- pb_ds::test::direct_mask_range_hashing_t_<
+ __gnu_pbds::detail::false_type,
+ __gnu_pbds::test::direct_mask_range_hashing_t_<
Allocator>,
access_half_load_check_resize_trigger_policy,
- pb_ds::test::hash_exponential_size_policy_t_<
+ __gnu_pbds::test::hash_exponential_size_policy_t_<
Allocator> >::type
regression_cc_policy1;
typedef
typename __gnu_cxx::typelist::create4<
- pb_ds::detail::true_type,
- pb_ds::test::direct_mod_range_hashing_t_<
+ __gnu_pbds::detail::true_type,
+ __gnu_pbds::test::direct_mod_range_hashing_t_<
Allocator>,
no_access_half_load_check_resize_trigger_policy,
- pb_ds::test::hash_prime_size_policy_t_ >::type
+ __gnu_pbds::test::hash_prime_size_policy_t_ >::type
regression_cc_policy2;
typedef
typename __gnu_cxx::typelist::create5<
- pb_ds::detail::false_type,
+ __gnu_pbds::detail::false_type,
lin_p_t,
- pb_ds::test::direct_mask_range_hashing_t_<
+ __gnu_pbds::test::direct_mask_range_hashing_t_<
Allocator>,
no_access_half_load_check_resize_trigger_policy,
- pb_ds::test::hash_exponential_size_policy_t_<
+ __gnu_pbds::test::hash_exponential_size_policy_t_<
Allocator> >::type
performance_gp_policy0;
typedef
typename __gnu_cxx::typelist::create5<
- pb_ds::detail::false_type,
+ __gnu_pbds::detail::false_type,
quad_p_t,
- pb_ds::test::direct_mod_range_hashing_t_<
+ __gnu_pbds::test::direct_mod_range_hashing_t_<
Allocator>,
no_access_half_load_check_resize_trigger_policy,
- pb_ds::test::hash_prime_size_policy_t_ >::type
+ __gnu_pbds::test::hash_prime_size_policy_t_ >::type
performance_gp_policy1;
typedef
typename __gnu_cxx::typelist::create5<
- pb_ds::detail::false_type,
+ __gnu_pbds::detail::false_type,
quad_p_t,
- pb_ds::test::direct_mod_range_hashing_t_<
+ __gnu_pbds::test::direct_mod_range_hashing_t_<
Allocator>,
access_half_load_check_resize_trigger_policy,
- pb_ds::test::hash_prime_size_policy_t_>::type
+ __gnu_pbds::test::hash_prime_size_policy_t_>::type
regression_gp_policy0;
typedef
typename __gnu_cxx::typelist::create5<
- pb_ds::detail::true_type,
+ __gnu_pbds::detail::true_type,
lin_p_t,
- pb_ds::test::direct_mask_range_hashing_t_<
+ __gnu_pbds::test::direct_mask_range_hashing_t_<
Allocator>,
access_half_load_check_resize_trigger_policy,
- pb_ds::test::hash_exponential_size_policy_t_<
+ __gnu_pbds::test::hash_exponential_size_policy_t_<
Allocator> >::type
regression_gp_policy1;
public:
typedef
- pb_ds::cc_hash_table<
+ __gnu_pbds::cc_hash_table<
Key,
Data,
Hash_Fn,
Eq_Fn,
comb_hash_fn,
- pb_ds::hash_standard_resize_policy<
+ __gnu_pbds::hash_standard_resize_policy<
size_policy,
trigger_policy,
false>,
public:
typedef
- pb_ds::cc_hash_table<
+ __gnu_pbds::cc_hash_table<
Key,
Data,
Hash_Fn,
Eq_Fn,
comb_hash_fn,
- pb_ds::hash_standard_resize_policy<
+ __gnu_pbds::hash_standard_resize_policy<
size_policy,
trigger_policy,
true>,
public:
typedef
- pb_ds::gp_hash_table<
+ __gnu_pbds::gp_hash_table<
Key,
Data,
Hash_Fn,
Eq_Fn,
comb_probe_fn,
probe_fn,
- pb_ds::hash_standard_resize_policy<
+ __gnu_pbds::hash_standard_resize_policy<
size_policy,
trigger_policy,
false>,
public:
typedef
- pb_ds::gp_hash_table<
+ __gnu_pbds::gp_hash_table<
Key,
Data,
Hash_Fn,
Eq_Fn,
comb_probe_fn,
probe_fn,
- pb_ds::hash_standard_resize_policy<
+ __gnu_pbds::hash_standard_resize_policy<
size_policy,
trigger_policy,
true>,
typedef typename Allocator::size_type size_type;
typedef
- pb_ds::test::hash_load_check_resize_trigger_t_<
+ __gnu_pbds::test::hash_load_check_resize_trigger_t_<
Allocator,
1, 8,
1, 2,
no_access_half_load_check_resize_trigger_policy;
typedef
- pb_ds::test::hash_load_check_resize_trigger_t_<
+ __gnu_pbds::test::hash_load_check_resize_trigger_t_<
Allocator,
1, 8,
1, 1,
no_access_one_load_check_resize_trigger_policy;
typedef
- pb_ds::hash_standard_resize_policy<
- pb_ds::test::hash_exponential_size_policy_t_<
+ __gnu_pbds::hash_standard_resize_policy<
+ __gnu_pbds::test::hash_exponential_size_policy_t_<
Allocator>,
no_access_half_load_check_resize_trigger_policy>
mask_half_resize_policy_t;
typedef
- pb_ds::hash_standard_resize_policy<
- pb_ds::test::hash_exponential_size_policy_t_<
+ __gnu_pbds::hash_standard_resize_policy<
+ __gnu_pbds::test::hash_exponential_size_policy_t_<
Allocator>,
no_access_one_load_check_resize_trigger_policy>
mask_one_resize_policy_t;
typedef
- pb_ds::hash_standard_resize_policy<
- pb_ds::test::hash_prime_size_policy_t_,
+ __gnu_pbds::hash_standard_resize_policy<
+ __gnu_pbds::test::hash_prime_size_policy_t_,
no_access_half_load_check_resize_trigger_policy>
mod_half_resize_policy_t;
typedef
- pb_ds::hash_standard_resize_policy<
- pb_ds::test::hash_prime_size_policy_t_,
+ __gnu_pbds::hash_standard_resize_policy<
+ __gnu_pbds::test::hash_prime_size_policy_t_,
no_access_one_load_check_resize_trigger_policy>
mod_one_resize_policy_t;
template<typename Allocator_>
struct half_resize_policy_selector<
- pb_ds::test::direct_mask_range_hashing_t_<
+ __gnu_pbds::test::direct_mask_range_hashing_t_<
Allocator_> >
{
typedef mask_half_resize_policy_t type;
template<typename Allocator_>
struct half_resize_policy_selector<
- pb_ds::test::direct_mod_range_hashing_t_<
+ __gnu_pbds::test::direct_mod_range_hashing_t_<
Allocator_> >
{
typedef mod_half_resize_policy_t type;
template<typename Allocator_>
struct one_resize_policy_selector<
- pb_ds::test::direct_mask_range_hashing_t_<
+ __gnu_pbds::test::direct_mask_range_hashing_t_<
Allocator_> >
{
typedef mask_one_resize_policy_t type;
template<typename Allocator_>
struct one_resize_policy_selector<
- pb_ds::test::direct_mod_range_hashing_t_<
+ __gnu_pbds::test::direct_mod_range_hashing_t_<
Allocator_> >
{
typedef mod_one_resize_policy_t type;
struct generic_cc_hash_table_t
{
typedef
- pb_ds::cc_hash_table<
+ __gnu_pbds::cc_hash_table<
Key,
Data,
- pb_ds::null_hash_fn,
+ __gnu_pbds::null_hash_fn,
Eq_Fn,
Comb_Hash_Fn,
typename one_resize_policy_selector<
struct no_access_generic_gp_hash_table_t
{
typedef
- pb_ds::gp_hash_table<
+ __gnu_pbds::gp_hash_table<
Key,
Data,
- pb_ds::null_hash_fn,
+ __gnu_pbds::null_hash_fn,
Eq_Fn,
Comb_Probe_Fn,
- pb_ds::null_probe_fn,
+ __gnu_pbds::null_probe_fn,
typename half_resize_policy_selector<
typename Comb_Probe_Fn::comb_fn>::type,
false,
private:
typedef typename Allocator::size_type size_type;
- typedef pb_ds::test::move_to_front_lu_policy_t_ mtf_u;
+ typedef __gnu_pbds::test::move_to_front_lu_policy_t_ mtf_u;
- typedef
pb_ds::test::counter_lu_policy_t_<Allocator, 5> cnt_5_u;
+ typedef
__gnu_pbds::test::counter_lu_policy_t_<Allocator, 5> cnt_5_u;
typedef typename __gnu_cxx::typelist::create1<mtf_u>::type lu_policy0;
public:
typedef
- pb_ds::list_update<
+ __gnu_pbds::list_update<
Key,
Data,
Eq_Fn,
class Node_Iterator,
class Cmp_Fn_,
class Allocator_>
- class Node_Update = pb_ds::null_tree_node_update,
+ class Node_Update = __gnu_pbds::null_tree_node_update,
class Allocator = std::allocator<std::pair<const Key, Data> > >
struct tree_common_types
{
private:
typedef
- pb_ds::tree<
+ __gnu_pbds::tree<
Key,
Data,
Cmp_Fn,
- pb_ds::ov_tree_tag,
+ __gnu_pbds::ov_tree_tag,
Node_Update,
Allocator>
ov_tree_assoc_container_t;
typedef
- pb_ds::tree<
+ __gnu_pbds::tree<
Key,
Data,
Cmp_Fn,
- pb_ds::rb_tree_tag,
+ __gnu_pbds::rb_tree_tag,
Node_Update,
Allocator>
rb_tree_assoc_container_t;
typedef
- pb_ds::tree<
+ __gnu_pbds::tree<
Key,
Data,
Cmp_Fn,
- pb_ds::splay_tree_tag,
+ __gnu_pbds::splay_tree_tag,
Node_Update,
Allocator>
splay_tree_assoc_container_t;
template<typename Key,
typename Data,
class E_Access_Traits =
- typename pb_ds::detail::default_trie_e_access_traits<Key>::type,
- class Tag = pb_ds::pat_trie_tag,
+ typename __gnu_pbds::detail::default_trie_e_access_traits<Key>::type,
+ class Tag = __gnu_pbds::pat_trie_tag,
template<typename Const_Node_Iterator,
typename Node_Iterator,
class E_Access_Traits_,
typename Allocator_>
- class Node_Update = pb_ds::null_trie_node_update,
+ class Node_Update = __gnu_pbds::null_trie_node_update,
class Allocator = std::allocator<char> >
class trie_common_types
{
private:
- typedef pb_ds::trie<Key, Data, E_Access_Traits, Tag, Node_Update, Allocator> type;
+ typedef __gnu_pbds::trie<Key, Data, E_Access_Traits, Tag, Node_Update, Allocator> type;
public:
typedef typename __gnu_cxx::typelist::create1<type>::type performance_tl;
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_COMMON_TYPES_HPP
#include <common_type/assoc/template_policy.hpp>
#include <io/xml.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_COMB_HASH_FN_STRING_FORM_HPP
#include <common_type/assoc/detail/store_hash_string_form.hpp>
#include <io/xml.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
template<typename Cntnr>
struct ds_string_form<
Cntnr,
- pb_ds::cc_hash_tag>
+ __gnu_pbds::cc_hash_tag>
{
static std::string
name()
template<typename Cntnr>
struct ds_string_form<
Cntnr,
- pb_ds::gp_hash_tag>
+ __gnu_pbds::gp_hash_tag>
{
static std::string
name()
template<typename Cntnr>
struct ds_string_form<
Cntnr,
- pb_ds::rb_tree_tag> : private tree_ds_string_form<
+ __gnu_pbds::rb_tree_tag> : private tree_ds_string_form<
Cntnr>
{
private:
template<typename Cntnr>
struct ds_string_form<
Cntnr,
- pb_ds::splay_tree_tag> : private tree_ds_string_form<
+ __gnu_pbds::splay_tree_tag> : private tree_ds_string_form<
Cntnr>
{
private:
template<typename Cntnr>
struct ds_string_form<
Cntnr,
- pb_ds::ov_tree_tag> : private tree_ds_string_form<
+ __gnu_pbds::ov_tree_tag> : private tree_ds_string_form<
Cntnr>
{
private:
template<typename Cntnr>
struct ds_string_form<
Cntnr,
- pb_ds::list_update_tag>
+ __gnu_pbds::list_update_tag>
{
static std::string
name()
template<typename Cntnr>
struct ds_string_form<
Cntnr,
- pb_ds::pat_trie_tag>
+ __gnu_pbds::pat_trie_tag>
{
static std::string
name()
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_DS_STRING_FORM_HPP
#include <common_type/assoc/template_policy.hpp>
#include <io/xml.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_LU_POLICY_STRING_FORM_HPP
#include <common_type/assoc/template_policy.hpp>
#include <io/xml.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
template<>
struct probe_fn_string_form<
- pb_ds::null_probe_fn>
+ __gnu_pbds::null_probe_fn>
{
static std::string
name()
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_PROBE_FN_STRING_FORM_HPP
#include <common_type/assoc/template_policy.hpp>
#include <io/xml.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
bool External_Size_Access,
typename Size_Type>
struct resize_policy_string_form<
- pb_ds::hash_standard_resize_policy<
+ __gnu_pbds::hash_standard_resize_policy<
Size_Policy,
Trigger_Policy,
External_Size_Access,
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_RESIZE_POLICY_STRING_FORM_HPP
#include <common_type/assoc/template_policy.hpp>
#include <io/xml.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
template<typename Allocator>
struct size_policy_string_form<
- pb_ds::test::hash_exponential_size_policy_t_<
+ __gnu_pbds::test::hash_exponential_size_policy_t_<
Allocator> >
{
static std::string
template<>
struct size_policy_string_form<
- pb_ds::test::hash_prime_size_policy_t_>
+ __gnu_pbds::test::hash_prime_size_policy_t_>
{
static std::string
name()
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_SIZE_POLICY_STRING_FORM_HPP
#include <common_type/assoc/template_policy.hpp>
#include <io/xml.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_STORE_HASH_STRING_FORM_HPP
#include <ext/pb_ds/tree_policy.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
enum
{
- value = pb_ds::detail::is_same<
+ value = __gnu_pbds::detail::is_same<
typename Tree_Cntnr::node_update,
- pb_ds::tree_order_statistics_node_update<
+ __gnu_pbds::tree_order_statistics_node_update<
typename Tree_Cntnr::const_node_iterator,
typename Tree_Cntnr::node_iterator,
typename Tree_Cntnr::cmp_fn,
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_TREE_SUPPORTS_ORDER_STATISTICS_HPP
#include <ext/pb_ds/trie_policy.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
enum
{
- value = pb_ds::detail::is_same<
+ value = __gnu_pbds::detail::is_same<
typename Tree_Cntnr::node_update,
- pb_ds::trie_order_statistics_node_update<
+ __gnu_pbds::trie_order_statistics_node_update<
typename Tree_Cntnr::const_node_iterator,
typename Tree_Cntnr::node_iterator,
typename Tree_Cntnr::e_access_traits,
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_TRIE_SUPPORTS_ORDER_STATISTICS_HPP
#include <ext/pb_ds/trie_policy.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
enum
{
- value = pb_ds::detail::is_same<
+ value = __gnu_pbds::detail::is_same<
typename Tree_Cntnr::node_update,
- pb_ds::trie_prefix_search_node_update<
+ __gnu_pbds::trie_prefix_search_node_update<
typename Tree_Cntnr::const_node_iterator,
typename Tree_Cntnr::node_iterator,
typename Tree_Cntnr::e_access_traits,
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_TRIE_SUPPORTS_PREFIX_SEARCH_HPP
#include <common_type/assoc/template_policy.hpp>
#include <io/xml.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
typename Allocator::size_type Max_Load_Denom,
bool External_Access>
struct trigger_policy_string_form<
- pb_ds::test::hash_load_check_resize_trigger_t_<
+ __gnu_pbds::test::hash_load_check_resize_trigger_t_<
Allocator,
Min_Load_Nom,
Min_Load_Denom,
typename Allocator::size_type Load_Denom,
bool External_Access>
struct trigger_policy_string_form<
- pb_ds::test::cc_hash_max_collision_check_resize_trigger_t_<
+ __gnu_pbds::test::cc_hash_max_collision_check_resize_trigger_t_<
Allocator,
Load_Nom,
Load_Denom,
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_TRIGGER_POLICY_STRING_FORM_HPP
#include <io/xml.hpp>
#include <string>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
{ return (make_xml_tag("type", "value", "std_set")); }
};
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <regression/basic_type.hpp>
#include <io/xml.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
{ return (""); }
static std::string
- name(pb_ds::null_mapped_type)
+ name(__gnu_pbds::null_mapped_type)
{ return ("set"); }
static std::string
- desc(pb_ds::null_mapped_type)
+ desc(__gnu_pbds::null_mapped_type)
{ return (""); }
public:
typename Cntnr::container_category>
{ };
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/list_update_policy.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
template<typename Allocator>
struct direct_mask_range_hashing_t_
- : public pb_ds::direct_mask_range_hashing<typename Allocator::size_type>
+ : public __gnu_pbds::direct_mask_range_hashing<typename Allocator::size_type>
{
typedef typename Allocator::size_type size_type;
- typedef pb_ds::direct_mask_range_hashing<size_type> base_type;
+ typedef __gnu_pbds::direct_mask_range_hashing<size_type> base_type;
};
template<typename Allocator>
struct direct_mod_range_hashing_t_
- : public pb_ds::direct_mod_range_hashing<typename Allocator::size_type>
+ : public __gnu_pbds::direct_mod_range_hashing<typename Allocator::size_type>
{
typedef typename Allocator::size_type size_type;
- typedef pb_ds::direct_mod_range_hashing<size_type> base_type;
+ typedef __gnu_pbds::direct_mod_range_hashing<size_type> base_type;
};
template<typename Allocator,
typename Allocator::size_type Max_Load_Denom,
bool External_Access>
struct hash_load_check_resize_trigger_t_
- : public pb_ds::hash_load_check_resize_trigger<External_Access,
+ : public __gnu_pbds::hash_load_check_resize_trigger<External_Access,
typename Allocator::size_type>
{
typedef typename Allocator::size_type size_type;
- typedef pb_ds::hash_load_check_resize_trigger<External_Access, size_type> base_type;
+ typedef __gnu_pbds::hash_load_check_resize_trigger<External_Access, size_type> base_type;
inline
hash_load_check_resize_trigger_t_()
typename Allocator::size_type Load_Denom,
bool External_Access>
struct cc_hash_max_collision_check_resize_trigger_t_
- : public pb_ds::cc_hash_max_collision_check_resize_trigger<External_Access,
+ : public __gnu_pbds::cc_hash_max_collision_check_resize_trigger<External_Access,
typename Allocator::size_type>
{
typedef typename Allocator::size_type size_type;
- typedef pb_ds::cc_hash_max_collision_check_resize_trigger<External_Access, size_type> base_type;
+ typedef __gnu_pbds::cc_hash_max_collision_check_resize_trigger<External_Access, size_type> base_type;
inline
cc_hash_max_collision_check_resize_trigger_t_()
};
};
- struct hash_prime_size_policy_t_ : public pb_ds::hash_prime_size_policy
+ struct hash_prime_size_policy_t_ : public __gnu_pbds::hash_prime_size_policy
{ };
template<typename Allocator>
struct hash_exponential_size_policy_t_
- : public pb_ds::hash_exponential_size_policy<typename Allocator::size_type>
+ : public __gnu_pbds::hash_exponential_size_policy<typename Allocator::size_type>
{ };
template<typename Key, class Allocator>
struct linear_probe_fn_t_
- : public pb_ds::linear_probe_fn<typename Allocator::size_type>
+ : public __gnu_pbds::linear_probe_fn<typename Allocator::size_type>
{ };
template<typename Key, class Allocator>
struct quadratic_probe_fn_t_
- : public pb_ds::quadratic_probe_fn<typename Allocator::size_type>
+ : public __gnu_pbds::quadratic_probe_fn<typename Allocator::size_type>
{ };
template<typename Allocator, typename Allocator::size_type Max_Count>
struct counter_lu_policy_t_
- : public pb_ds::counter_lu_policy<Max_Count, Allocator>
+ : public __gnu_pbds::counter_lu_policy<Max_Count, Allocator>
{
- typedef pb_ds::counter_lu_policy<Max_Count, Allocator> base_type;
+ typedef __gnu_pbds::counter_lu_policy<Max_Count, Allocator> base_type;
};
struct move_to_front_lu_policy_t_
- : public pb_ds::move_to_front_lu_policy<>
+ : public __gnu_pbds::move_to_front_lu_policy<>
{ };
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <ext/pb_ds/priority_queue.hpp>
#include <ext/typelist.h>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
private:
// typedef typename Allocator::size_type size_type;
- typedef pb_ds::priority_queue<Value_Type, Cmp_Fn, pb_ds::pairing_heap_tag, Allocator> pairing_heap_t;
+ typedef __gnu_pbds::priority_queue<Value_Type, Cmp_Fn, __gnu_pbds::pairing_heap_tag, Allocator> pairing_heap_t;
- typedef pb_ds::priority_queue<Value_Type, Cmp_Fn, pb_ds::binomial_heap_tag, Allocator> binomial_heap_t;
+ typedef __gnu_pbds::priority_queue<Value_Type, Cmp_Fn, __gnu_pbds::binomial_heap_tag, Allocator> binomial_heap_t;
- typedef pb_ds::priority_queue<Value_Type, Cmp_Fn, pb_ds::rc_binomial_heap_tag, Allocator> rc_binomial_heap_t;
+ typedef __gnu_pbds::priority_queue<Value_Type, Cmp_Fn, __gnu_pbds::rc_binomial_heap_tag, Allocator> rc_binomial_heap_t;
- typedef pb_ds::priority_queue<Value_Type, Cmp_Fn, pb_ds::binary_heap_tag, Allocator> binary_heap_t;
+ typedef __gnu_pbds::priority_queue<Value_Type, Cmp_Fn, __gnu_pbds::binary_heap_tag, Allocator> binary_heap_t;
- typedef pb_ds::priority_queue<Value_Type, Cmp_Fn, pb_ds::thin_heap_tag, Allocator> thin_heap_t;
+ typedef __gnu_pbds::priority_queue<Value_Type, Cmp_Fn, __gnu_pbds::thin_heap_tag, Allocator> thin_heap_t;
typedef typename __gnu_cxx::typelist::create5<thin_heap_t, pairing_heap_t, binomial_heap_t, rc_binomial_heap_t, binary_heap_t>::type all_tl;
};
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_COMMON_TYPES_HPP
#include <ext/pb_ds/tag_and_trait.hpp>
#include <io/xml.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
struct ds_string_form;
template<typename Cntnr>
- struct ds_string_form<Cntnr, pb_ds::pairing_heap_tag>
+ struct ds_string_form<Cntnr, __gnu_pbds::pairing_heap_tag>
{
static std::string
name()
};
template<typename Cntnr>
- struct ds_string_form<Cntnr, pb_ds::thin_heap_tag>
+ struct ds_string_form<Cntnr, __gnu_pbds::thin_heap_tag>
{
static std::string
name()
};
template<typename Cntnr>
- struct ds_string_form<Cntnr, pb_ds::binomial_heap_tag>
+ struct ds_string_form<Cntnr, __gnu_pbds::binomial_heap_tag>
{
static std::string
name()
};
template<typename Cntnr>
- struct ds_string_form<Cntnr, pb_ds::rc_binomial_heap_tag>
+ struct ds_string_form<Cntnr, __gnu_pbds::rc_binomial_heap_tag>
{
static std::string
name()
};
template<typename Cntnr>
- struct ds_string_form<Cntnr, pb_ds::binary_heap_tag>
+ struct ds_string_form<Cntnr, __gnu_pbds::binary_heap_tag>
{
static std::string
name()
} // namespace detail
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_DS_STRING_FORM_HPP
#include <common_type/priority_queue/detail/ds_string_form.hpp>
#include <io/xml.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
: public detail::tag_select_string_form<Cntnr, typename Cntnr::container_category>
{ };
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_STRING_FORM_HPP
#include <string>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
return ret;
}
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_DNA_STR_LIMIT_HPP
#include <string>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
size_t limit_string_hash_fn::_S_max;
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <string>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
}
};
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <string>
#include <hash_fn/dna_str_limit.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
{ return ("string ranged-hash using" + string_form<comb_fn>::desc()); }
};
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <string>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
{ return ("string ranged-probe using" + string_form<comb_fn>::desc());}
};
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <exception>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
#endif
}
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_ILLEGAL_INPUT_EX_HPP
#include <util/io/prog_bar.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#include <iostream>
#include <string>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_PROG_BAR_HPP
#include <string>
#include <iostream>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
std::cerr << "Cannot open file " << r_f_name.c_str() <<
std::endl;
- throw pb_ds::test::illegal_input_error();
+ throw __gnu_pbds::test::illegal_input_error();
}
size_t i = 0;
std::cerr << "Read only " << static_cast<unsigned long>(i) <<
" words" << std::endl;
- throw pb_ds::test::illegal_input_error();
+ throw __gnu_pbds::test::illegal_input_error();
}
}
catch(...)
std::cerr << "Cannot open file " << r_f_name.c_str() <<
std::endl;
- throw pb_ds::test::illegal_input_error();
+ throw __gnu_pbds::test::illegal_input_error();
}
typedef std::set< typename Vec::value_type::first_type> set_t;
std::cerr << "Read only " << static_cast<unsigned long>(s.size()) <<
" words" << std::endl;
- throw pb_ds::test::illegal_input_error();
+ throw __gnu_pbds::test::illegal_input_error();
}
}
catch(...)
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_TEXT_POPULATE_HPP
#include <stdlib.h>
#include <bits/functexcept.h>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
return false;
}
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#include <io/illegal_input_error.hpp>
#include <string>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
bool
get_cmd_line_bool(int argc, char* a_p_argv[], int argn);
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_VERIFIED_CMD_LINE_INPUT_HPP
#include <string>
#include <sstream>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
return sstrm.str();
}
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_XML_HPP
#include <iostream>
#include <io/xml.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
{ std::cout << "</cntnr>" << std::endl; }
};
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_XML_TEST_FORMATTER_HPP
#include <ext/hash_map>
#endif
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
template<typename Key,
typename Data,
size_t Init_Size = 8,
- typename Hash_Fn = typename pb_ds::detail::default_hash_fn<Key>::type,
+ typename Hash_Fn = typename __gnu_pbds::detail::default_hash_fn<Key>::type,
typename Eq_Fn = std::equal_to<Key>,
typename Less_Fn = std::less<Key>,
typename Allocator = std::allocator<char>
#undef PB_DS_BASE_C_DEC
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <native_type/assoc/native_hash_tag.hpp>
#include <io/xml.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
template<typename Key,
typename Data,
size_t Init_Size = 8,
- class Hash_Fn = typename pb_ds::detail::default_hash_fn<Key>::type,
+ class Hash_Fn = typename __gnu_pbds::detail::default_hash_fn<Key>::type,
class Eq_Fn = std::equal_to<Key>,
class Less_Fn = std::less<Key>,
class Allocator = std::allocator<char> >
#undef PB_DS_BASE_C_DEC
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <ext/hash_set>
#endif
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
template<typename Key,
size_t Init_Size = 8,
- typename Hash_Fn = typename pb_ds::detail::default_hash_fn<Key>::type,
+ typename Hash_Fn = typename __gnu_pbds::detail::default_hash_fn<Key>::type,
typename Eq_Fn = std::equal_to<Key>,
typename Less_Fn = std::less<Key>,
typename Allocator = std::allocator<char>
#undef PB_DS_BASE_C_DEC
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#ifndef PB_DS_NATIVE_HASH_DS_TAG_HPP
#define PB_DS_NATIVE_HASH_DS_TAG_HPP
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
struct native_hash_tag { };
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <native_type/assoc/native_tree_tag.hpp>
#include <io/xml.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_NATIVE_MAP_HPP
#include <ext/pb_ds/detail/type_utils.hpp>
#include <native_type/assoc/native_tree_tag.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
#undef PB_DS_BASE_C_DEC
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_NATIVE_MULTIMAP_HPP
#include <native_type/assoc/native_tree_tag.hpp>
#include <io/xml.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
#undef PB_DS_BASE_C_DEC
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_NATIVE_SET_HPP
#ifndef PB_DS_NATIVE_TREE_DS_TAG_HPP
#define PB_DS_NATIVE_TREE_DS_TAG_HPP
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
struct native_tree_tag
{ };
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <ext/pb_ds/detail/type_utils.hpp>
#include <io/xml.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
#undef PB_DS_CLASS_C_DEC
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <performance/io/xml_formatter.hpp>
#include <common_type/assoc/string_form.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
}
}
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <performance/io/xml_formatter.hpp>
#include <common_type/assoc/string_form.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
template<typename Cntnr>
size_t
- insert(Cntnr, It ins_it_b, It ins_it_e, pb_ds::detail::true_type);
+ insert(Cntnr, It ins_it_b, It ins_it_e, __gnu_pbds::detail::true_type);
template<typename Cntnr>
size_t
- insert(Cntnr, It ins_it_b, It ins_it_e, pb_ds::detail::false_type);
+ insert(Cntnr, It ins_it_b, It ins_it_e, __gnu_pbds::detail::false_type);
const It m_ins_b;
const size_t m_ins_vn;
std::advance(ins_it_e, ins_size);
const size_t delta_mem = insert(Cntnr(), ins_it_b, ins_it_e,
- pb_ds::detail::integral_constant<int,Native>());
+ __gnu_pbds::detail::integral_constant<int,Native>());
res_set_fmt.add_res(ins_size, static_cast<double>(delta_mem));
}
template<typename Cntnr>
size_t
multimap_insert_test<It, Native>::
- insert(Cntnr, It ins_it_b, It ins_it_e, pb_ds::detail::true_type)
+ insert(Cntnr, It ins_it_b, It ins_it_e, __gnu_pbds::detail::true_type)
{
typedef __gnu_test::tracker_allocator_counter counter_type;
__gnu_test::tracker_allocator<char> alloc;
template<typename Cntnr>
size_t
multimap_insert_test<It, Native>::
- insert(Cntnr, It ins_it_b, It ins_it_e, pb_ds::detail::false_type)
+ insert(Cntnr, It ins_it_b, It ins_it_e, __gnu_pbds::detail::false_type)
{
typedef __gnu_test::tracker_allocator_counter counter_type;
__gnu_test::tracker_allocator<char> alloc;
return (final_mem - init_mem);
}
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <hash_fn/string_hash_fn.hpp>
#include <common_type/assoc/common_type.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
struct hash_set_tl_t
{
typedef
- typename pb_ds::test::hash_common_types<
+ typename __gnu_pbds::test::hash_common_types<
Key,
- pb_ds::null_mapped_type,
+ __gnu_pbds::null_mapped_type,
int_hash,
std::equal_to<Key>,
Allocator>::performance_min_tl
struct lu_set_tl_t
{
typedef
- typename pb_ds::test::lu_common_types<
+ typename __gnu_pbds::test::lu_common_types<
Key,
- pb_ds::null_mapped_type,
+ __gnu_pbds::null_mapped_type,
std::equal_to<
Key>,
Allocator>::performance_min_tl
{
private:
typedef
- typename pb_ds::detail::__conditional_type<
- pb_ds::detail::is_same<
+ typename __gnu_pbds::detail::__conditional_type<
+ __gnu_pbds::detail::is_same<
int,
Key>::value,
int_hash,
struct hash_mmap_transform
{
typedef
- typename pb_ds::test::hash_common_types<
+ typename __gnu_pbds::test::hash_common_types<
Key,
Cntnr_T,
hash_fn_t,
struct tree_mmap_transform
{
typedef
- typename pb_ds::test::tree_common_types<
+ typename __gnu_pbds::test::tree_common_types<
Key,
Cntnr_T,
std::less<
Key>,
- pb_ds::null_tree_node_update,
+ __gnu_pbds::null_tree_node_update,
Allocator>::performance_min_tl
type;
};
};
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <common_type/assoc/common_type.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
typedef
- pb_ds::test::hash_common_types<
+ __gnu_pbds::test::hash_common_types<
int,
- pb_ds::null_mapped_type>::tl
+ __gnu_pbds::null_mapped_type>::tl
hash_set_tl_t;
template<typename Cntnr_T>
struct hash_mmap_transform
{
typedef
- typename pb_ds::test::hash_common_types<
+ typename __gnu_pbds::test::hash_common_types<
int,
- pb_ds::compound_data_type<
+ __gnu_pbds::compound_data_type<
Cntnr_T> >::tl
type;
};
hash_mmap_tl_t;
typedef
- pb_ds::test::tree_common_types<
+ __gnu_pbds::test::tree_common_types<
int,
- pb_ds::null_mapped_type>::tl
+ __gnu_pbds::null_mapped_type>::tl
tree_set_tl_t;
template<typename Cntnr_T>
struct tree_mmap_transform
{
typedef
- typename pb_ds::test::tree_common_types<
+ typename __gnu_pbds::test::tree_common_types<
int,
- pb_ds::compound_data_type<
+ __gnu_pbds::compound_data_type<
Cntnr_T> >::tl
type;
};
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_MULTIMAP_RANDOM_INT_INSERT_TEST_COMMON_TYPE_HPP
#include <common_type/assoc/string_form.hpp>
#include <iterator>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
} // namespace detail
template<typename It, bool LOR = false>
- class find_test : private pb_ds::test::detail::timing_test_base
+ class find_test : private __gnu_pbds::test::detail::timing_test_base
{
public:
find_test(It ins_b, It fnd_it_b, size_t ins_vn, size_t ins_vs,
It fnd_it_e = m_fnd_it_b;
std::advance(fnd_it_e, fnd_size);
- pb_ds::test::detail::find_find_functor<It, Cntnr, LOR>
+ __gnu_pbds::test::detail::find_find_functor<It, Cntnr, LOR>
fn(test_container, fnd_it_b, fnd_it_e);
const double res =
- pb_ds::test::detail::timing_test_base::operator()(fn);
+ __gnu_pbds::test::detail::timing_test_base::operator()(fn);
res_set_fmt.add_res(v, res / fnd_size);
}
}
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <common_type/assoc/string_form.hpp>
#include <iterator>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
} // namespace detail
template<typename It>
- class insert_test : private pb_ds::test::detail::timing_test_base
+ class insert_test : private __gnu_pbds::test::detail::timing_test_base
{
public:
insert_test(It ins_b, size_t ins_vn, size_t ins_vs, size_t ins_vm)
It ins_it_e = m_ins_b;
std::advance(ins_it_e, v);
- pb_ds::test::detail::insert_insert_functor<It, Cntnr>
+ __gnu_pbds::test::detail::insert_insert_functor<It, Cntnr>
fn(ins_it_b, ins_it_e);
const double res =
- pb_ds::test::detail::timing_test_base::operator()(fn);
+ __gnu_pbds::test::detail::timing_test_base::operator()(fn);
res_set_fmt.add_res(v, res / v);
}
cntnr.insert((typename Cntnr::const_reference)(*ins_it));
}
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <common_type/assoc/string_form.hpp>
#include <iterator>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
template<typename It, bool Native>
- class multimap_find_test : private pb_ds::test::detail::timing_test_base
+ class multimap_find_test : private __gnu_pbds::test::detail::timing_test_base
{
public:
multimap_find_test(It ins_b, size_t ins_vn, size_t vs, size_t ins_vm)
template<typename Cntnr>
Cntnr
- init(It ins_b, It ins_e, Cntnr, pb_ds::detail::true_type)
+ init(It ins_b, It ins_e, Cntnr, __gnu_pbds::detail::true_type)
{ return Cntnr(ins_b, ins_e); }
template<typename Cntnr>
Cntnr
- init(It ins_b, It ins_e, Cntnr, pb_ds::detail::false_type)
+ init(It ins_b, It ins_e, Cntnr, __gnu_pbds::detail::false_type)
{
Cntnr ret;
for (It it = ins_b; it != ins_e; ++it)
std::advance(ins_it_e, v);
Cntnr c = init(ins_it_b, ins_it_e, Cntnr(),
- pb_ds::detail::integral_constant<int,Native>());
+ __gnu_pbds::detail::integral_constant<int,Native>());
- pb_ds::test::detail::multimap_find_functor<It, Cntnr, Native>
+ __gnu_pbds::test::detail::multimap_find_functor<It, Cntnr, Native>
fn(c, ins_it_b, ins_it_e);
const double res =
- pb_ds::test::detail::timing_test_base::operator()(fn);
+ __gnu_pbds::test::detail::timing_test_base::operator()(fn);
res_set_fmt.add_res(v, res / v);
}
}
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <common_type/assoc/string_form.hpp>
#include <iterator>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
} // namespace detail
template<typename It, bool Native>
- class multimap_insert_test : private pb_ds::test::detail::timing_test_base
+ class multimap_insert_test : private __gnu_pbds::test::detail::timing_test_base
{
public:
multimap_insert_test(It b, size_t ins_vn, size_t ins_vs, size_t ins_vm)
It ins_it_e = m_ins_b;
std::advance(ins_it_e, v);
- pb_ds::test::detail::multimap_insert_functor<It, Cntnr, Native>
+ __gnu_pbds::test::detail::multimap_insert_functor<It, Cntnr, Native>
fn(ins_it_b, ins_it_e);
const double res =
- pb_ds::test::detail::timing_test_base::operator()(fn);
+ __gnu_pbds::test::detail::timing_test_base::operator()(fn);
res_set_fmt.add_res(v, res / v);
}
}
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <common_type/assoc/string_form.hpp>
#include <iterator>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
} // namespace detail
template<typename It>
- class subscript_find_test : private pb_ds::test::detail::timing_test_base
+ class subscript_find_test : private __gnu_pbds::test::detail::timing_test_base
{
public:
subscript_find_test(It ins_b, It b, size_t ins_vn, size_t ins_vs,
It fnd_it_e = m_fnd_b;
std::advance(fnd_it_e, fnd_size);
- pb_ds::test::detail::subscript_find_functor<It, Cntnr>
+ __gnu_pbds::test::detail::subscript_find_functor<It, Cntnr>
fn(test_container, fnd_it_b, fnd_it_e);
const double res =
- pb_ds::test::detail::timing_test_base::operator()(fn);
+ __gnu_pbds::test::detail::timing_test_base::operator()(fn);
res_set_fmt.add_res(v, res / fnd_size);
}
}
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <common_type/assoc/string_form.hpp>
#include <iterator>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
} // namespace detail
template<typename It>
- class subscript_insert_test : private pb_ds::test::detail::timing_test_base
+ class subscript_insert_test : private __gnu_pbds::test::detail::timing_test_base
{
public:
subscript_insert_test(It ins_b, It b, size_t ins_vn, size_t ins_vs,
It ins_it_b = m_ins_b;
It ins_it_e = m_ins_b;
std::advance(ins_it_e, v);
- pb_ds::test::detail::subscript_insert_functor<It, Cntnr>
+ __gnu_pbds::test::detail::subscript_insert_functor<It, Cntnr>
fn(ins_it_b, ins_it_e);
const double res =
- pb_ds::test::detail::timing_test_base::operator()(fn);
+ __gnu_pbds::test::detail::timing_test_base::operator()(fn);
res_set_fmt.add_res(v, res / v);
}
}
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <iterator>
#include <cstdlib>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
enum
{
support_detected =
- pb_ds::test::detail::tree_supports_order_statistics<Cntnr>::value
+ __gnu_pbds::test::detail::tree_supports_order_statistics<Cntnr>::value
};
PB_DS_STATIC_ASSERT(correct_type, support_detected);
template<bool Support_Order_Statistics>
class tree_order_statistics_test
- : private pb_ds::test::detail::timing_test_base
+ : private __gnu_pbds::test::detail::timing_test_base
{
public:
tree_order_statistics_test(size_t vn, size_t vs, size_t vm)
template<typename Cntnr>
void
- order_statistics(Cntnr& r_container, pb_ds::detail::true_type);
+ order_statistics(Cntnr& r_container, __gnu_pbds::detail::true_type);
template<typename Cntnr>
void
- order_statistics(Cntnr& r_container, pb_ds::detail::false_type);
+ order_statistics(Cntnr& r_container, __gnu_pbds::detail::false_type);
private:
const size_t m_vn;
for (size_t ins = 0; ins < v; ++ ins)
cntnr.insert((typename Cntnr::value_type)ins);
- pb_ds::test::detail::order_statistics_functor<Cntnr, Support_Order_Statistics>
+ __gnu_pbds::test::detail::order_statistics_functor<Cntnr, Support_Order_Statistics>
fn(cntnr);
const double res =
- pb_ds::test::detail::timing_test_base::operator()(fn);
+ __gnu_pbds::test::detail::timing_test_base::operator()(fn);
res_set_fmt.add_res(v, res / v);
}
}
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <common_type/assoc/string_form.hpp>
#include <iterator>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
} // namespace detail
template<bool Support_Split_Join>
- class tree_split_join_test : private pb_ds::test::detail::timing_test_base
+ class tree_split_join_test : private __gnu_pbds::test::detail::timing_test_base
{
public:
tree_split_join_test(size_t vn, size_t vs, size_t vm);
for (size_t ins = 0; ins < v; ++ ins)
cntnr.insert((typename Cntnr::value_type)ins);
- pb_ds::test::detail::split_join_functor<Cntnr, Support_Split_Join>
+ __gnu_pbds::test::detail::split_join_functor<Cntnr, Support_Split_Join>
fn(cntnr);
const double res =
- pb_ds::test::detail::timing_test_base::operator()(fn);
+ __gnu_pbds::test::detail::timing_test_base::operator()(fn);
res_set_fmt.add_res(v, res);
}
}
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <iostream>
#include <io/xml_test_formatter.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
}
};
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_XML_TEST_PERFORMANCE_FORMATTER_HPP
#include <performance/io/xml_formatter.hpp>
#include <common_type/priority_queue/string_form.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
}
}
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <common_type/priority_queue/string_form.hpp>
#include <iterator>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
} // namespace detail
template<typename It>
- class join_test : private pb_ds::test::detail::timing_test_base
+ class join_test : private __gnu_pbds::test::detail::timing_test_base
{
public:
join_test(It ins_b, size_t ins_vn, size_t ins_vs, size_t ins_vm)
void
operator()(Cntnr)
{
- using pb_ds::test::detail::double_push_functor;
- using pb_ds::test::detail::double_push_join_functor;
- typedef pb_ds::test::detail::timing_test_base base_type;
+ using __gnu_pbds::test::detail::double_push_functor;
+ using __gnu_pbds::test::detail::double_push_join_functor;
+ typedef __gnu_pbds::test::detail::timing_test_base base_type;
typedef double_push_functor<It, Cntnr> psh_fnct;
typedef double_push_join_functor<It, Cntnr> psh_jn_fnct;
const size_t m_ins_vm;
};
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <common_type/priority_queue/string_form.hpp>
#include <iterator>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
// Specializations.
template<typename It, class Cntnr>
- class push_functor<It, Cntnr, pb_ds::binary_heap_tag>
+ class push_functor<It, Cntnr, __gnu_pbds::binary_heap_tag>
{
public:
push_functor(It ins_it_b, It ins_it_e)
};
template<typename It, class Cntnr>
- class push_functor<It, Cntnr, pb_ds::test::native_pq_tag>
+ class push_functor<It, Cntnr, __gnu_pbds::test::native_pq_tag>
{
public:
push_functor(It ins_it_b, It ins_it_e)
template<typename It, class Cntnr>
- class push_modify_functor<It, Cntnr, pb_ds::binary_heap_tag>
+ class push_modify_functor<It, Cntnr, __gnu_pbds::binary_heap_tag>
{
private:
typedef typename Cntnr::iterator iterator;
};
template<typename It, class Cntnr>
- class push_modify_functor<It, Cntnr, pb_ds::test::native_pq_tag>
+ class push_modify_functor<It, Cntnr, __gnu_pbds::test::native_pq_tag>
{
private:
typedef typename Cntnr::value_type value_type;
} // namespace detail
template<typename It>
- class modify_test : private pb_ds::test::detail::timing_test_base
+ class modify_test : private __gnu_pbds::test::detail::timing_test_base
{
public:
modify_test(It b, size_t vn, size_t vs, size_t vm, bool modify_up)
}
}
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <common_type/priority_queue/string_form.hpp>
#include <iterator>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
} // namespace detail
template<typename It>
- class push_pop_test : private pb_ds::test::detail::timing_test_base
+ class push_pop_test : private __gnu_pbds::test::detail::timing_test_base
{
public:
push_pop_test(It ins_b, size_t ins_vn, size_t ins_vs, size_t ins_vm)
It ins_it_e = m_ins_b;
std::advance(ins_it_e, v);
- pb_ds::test::detail::push_pop_push_pop_functor<It, Cntnr>
+ __gnu_pbds::test::detail::push_pop_push_pop_functor<It, Cntnr>
fn(ins_it_b, ins_it_e);
const double res =
- pb_ds::test::detail::timing_test_base::operator()(fn);
+ __gnu_pbds::test::detail::timing_test_base::operator()(fn);
res_set_fmt.add_res(v, res / v);
}
}
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <common_type/priority_queue/string_form.hpp>
#include <iterator>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
} // namespace detail
template<typename It>
- class push_test : private pb_ds::test::detail::timing_test_base
+ class push_test : private __gnu_pbds::test::detail::timing_test_base
{
public:
push_test(It ins_b, size_t ins_vn, size_t ins_vs, size_t ins_vm)
It ins_it_e = m_ins_b;
std::advance(ins_it_e, v);
- pb_ds::test::detail::push_push_functor<It, Cntnr>
+ __gnu_pbds::test::detail::push_push_functor<It, Cntnr>
fn(ins_it_b, ins_it_e);
const double res =
- pb_ds::test::detail::timing_test_base::operator()(fn);
+ __gnu_pbds::test::detail::timing_test_base::operator()(fn);
res_set_fmt.add_res(v, res / v);
}
cntnr.push((typename Cntnr::const_reference)(*ins_it));
}
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <util/performance/time/elapsed_timer.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#include <time.h>
#include <iosfwd>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_TEST_TIME_HPP
#include <performance/time/elapsed_timer.hpp>
#include <statistic/result_recorder.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
timing_test_base::operator()(Functor& fn)
{
const std::size_t resolution = get_min_resolution(fn);
- pb_ds::test::detail::result_recorder<double> rec;
+ __gnu_pbds::test::detail::result_recorder<double> rec;
double res;
do
res = run_at_resolution(fn, resolution);
} // namespace detail
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <regression/basic_type.hpp>
#include <common_type/assoc/common_type.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
}
};
- typedef pb_ds::string_trie_e_access_traits<basic_type, 'a', 'a' + basic_type::distinct_chars - 1, false, alloc_type> e_access_traits_t;
+ typedef __gnu_pbds::string_trie_e_access_traits<basic_type, 'a', 'a' + basic_type::distinct_chars - 1, false, alloc_type> e_access_traits_t;
template<typename Data_Type>
struct tree_types
{
private:
- typedef typename tree_common_types<basic_type, Data_Type, std::less<basic_type>, pb_ds::null_tree_node_update, alloc_type>::regression_tl no_order_statistics_tl_t;
+ typedef typename tree_common_types<basic_type, Data_Type, std::less<basic_type>, __gnu_pbds::null_tree_node_update, alloc_type>::regression_tl no_order_statistics_tl_t;
- typedef typename tree_common_types<basic_type, Data_Type, std::less<basic_type>, pb_ds::tree_order_statistics_node_update, alloc_type>::regression_tl order_statistics_tl_t;
+ typedef typename tree_common_types<basic_type, Data_Type, std::less<basic_type>, __gnu_pbds::tree_order_statistics_node_update, alloc_type>::regression_tl order_statistics_tl_t;
public:
typedef typename __gnu_cxx::typelist::append<no_order_statistics_tl_t, order_statistics_tl_t>::type tl_t;
struct trie_types
{
private:
- typedef typename trie_common_types<basic_type, Data_Type, e_access_traits_t, pb_ds::pat_trie_tag, pb_ds::null_trie_node_update, alloc_type>::regression_tl no_updates_tl_t;
+ typedef typename trie_common_types<basic_type, Data_Type, e_access_traits_t, __gnu_pbds::pat_trie_tag, __gnu_pbds::null_trie_node_update, alloc_type>::regression_tl no_updates_tl_t;
- typedef typename trie_common_types<basic_type, Data_Type, e_access_traits_t, pb_ds::pat_trie_tag, pb_ds::trie_order_statistics_node_update, alloc_type>::regression_tl order_statistics_tl_t;
+ typedef typename trie_common_types<basic_type, Data_Type, e_access_traits_t, __gnu_pbds::pat_trie_tag, __gnu_pbds::trie_order_statistics_node_update, alloc_type>::regression_tl order_statistics_tl_t;
- typedef typename trie_common_types<basic_type, Data_Type, e_access_traits_t, pb_ds::pat_trie_tag, pb_ds::trie_prefix_search_node_update, alloc_type>::regression_tl prefix_search_tl_t;
+ typedef typename trie_common_types<basic_type, Data_Type, e_access_traits_t, __gnu_pbds::pat_trie_tag, __gnu_pbds::trie_prefix_search_node_update, alloc_type>::regression_tl prefix_search_tl_t;
public:
typedef typename __gnu_cxx::typelist::append<no_updates_tl_t, typename __gnu_cxx::typelist::append<prefix_search_tl_t, order_statistics_tl_t>::type>::type tl_t;
typedef trie_types<basic_type>::tl_t trie_map_tl_t;
typedef trie_types<basic_type>::min_tl_t min_trie_map_tl_t;
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <string>
#include <ext/throw_allocator.h>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
#undef PB_DS_BASE_C_DEC
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <regression/basic_type.hpp>
#include <common_type/priority_queue/common_type.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
typedef pq_tl_t min_pq_tl_t;
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <common_type/assoc/string_form.hpp>
#include <regression/rand/io/assoc/xml_formatter.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
typedef typename test_traits::value_type value_type;
typedef typename test_traits::native_type native_type;
typedef twister_rand_gen gen;
- typedef pb_ds::container_traits<Cntnr> container_traits;
+ typedef __gnu_pbds::container_traits<Cntnr> container_traits;
typedef __gnu_cxx::throw_allocator<char> alloc_t;
enum op
iterator_defs();
static void
- node_iterator_defs(pb_ds::detail::false_type);
+ node_iterator_defs(__gnu_pbds::detail::false_type);
static void
- node_iterator_defs(pb_ds::detail::true_type);
+ node_iterator_defs(__gnu_pbds::detail::true_type);
static void
policy_defs();
static void
- policy_defs(pb_ds::basic_hash_tag);
+ policy_defs(__gnu_pbds::basic_hash_tag);
static void
- policy_defs(pb_ds::cc_hash_tag);
+ policy_defs(__gnu_pbds::cc_hash_tag);
static void
- policy_defs(pb_ds::gp_hash_tag);
+ policy_defs(__gnu_pbds::gp_hash_tag);
static void
- policy_defs(pb_ds::tree_tag);
+ policy_defs(__gnu_pbds::tree_tag);
static void
- policy_defs(pb_ds::list_update_tag);
+ policy_defs(__gnu_pbds::list_update_tag);
static void
- policy_defs(pb_ds::pat_trie_tag);
+ policy_defs(__gnu_pbds::pat_trie_tag);
void
policy_access();
void
- policy_access(pb_ds::basic_hash_tag);
+ policy_access(__gnu_pbds::basic_hash_tag);
void
- policy_access(pb_ds::cc_hash_tag);
+ policy_access(__gnu_pbds::cc_hash_tag);
void
- policy_access(pb_ds::gp_hash_tag);
+ policy_access(__gnu_pbds::gp_hash_tag);
void
- policy_access(pb_ds::tree_tag);
+ policy_access(__gnu_pbds::tree_tag);
void
- policy_access(pb_ds::list_update_tag);
+ policy_access(__gnu_pbds::list_update_tag);
void
- policy_access(pb_ds::pat_trie_tag);
+ policy_access(__gnu_pbds::pat_trie_tag);
void
it_copy();
rev_it_assign();
void
- rev_it_copy_imp(pb_ds::detail::false_type);
+ rev_it_copy_imp(__gnu_pbds::detail::false_type);
void
- rev_it_copy_imp(pb_ds::detail::true_type);
+ rev_it_copy_imp(__gnu_pbds::detail::true_type);
void
- rev_it_assign_imp(pb_ds::detail::false_type);
+ rev_it_assign_imp(__gnu_pbds::detail::false_type);
void
- rev_it_assign_imp(pb_ds::detail::true_type);
+ rev_it_assign_imp(__gnu_pbds::detail::true_type);
bool
default_constructor();
it_constructor();
bool
- it_constructor_imp(pb_ds::cc_hash_tag);
+ it_constructor_imp(__gnu_pbds::cc_hash_tag);
bool
- it_constructor_imp(pb_ds::gp_hash_tag);
+ it_constructor_imp(__gnu_pbds::gp_hash_tag);
bool
- it_constructor_imp(pb_ds::tree_tag);
+ it_constructor_imp(__gnu_pbds::tree_tag);
bool
- it_constructor_imp(pb_ds::list_update_tag);
+ it_constructor_imp(__gnu_pbds::list_update_tag);
bool
- it_constructor_imp(pb_ds::pat_trie_tag);
+ it_constructor_imp(__gnu_pbds::pat_trie_tag);
bool
insert();
erase_it();
bool
- erase_it_imp(pb_ds::detail::false_type);
+ erase_it_imp(__gnu_pbds::detail::false_type);
bool
- erase_it_imp(pb_ds::detail::true_type);
+ erase_it_imp(__gnu_pbds::detail::true_type);
bool
erase_rev_it();
bool
- erase_rev_it_imp(pb_ds::detail::false_type);
+ erase_rev_it_imp(__gnu_pbds::detail::false_type);
bool
- erase_rev_it_imp(pb_ds::detail::true_type);
+ erase_rev_it_imp(__gnu_pbds::detail::true_type);
bool
erase_if();
resize();
bool
- resize_imp(pb_ds::detail::true_type);
+ resize_imp(__gnu_pbds::detail::true_type);
bool
- resize_imp(pb_ds::detail::false_type);
+ resize_imp(__gnu_pbds::detail::false_type);
bool
get_set_loads();
bool
- get_set_loads_imp(pb_ds::detail::true_type);
+ get_set_loads_imp(__gnu_pbds::detail::true_type);
bool
- get_set_loads_imp(pb_ds::detail::false_type);
+ get_set_loads_imp(__gnu_pbds::detail::false_type);
void
get_set_load();
void
- get_set_load_imp(pb_ds::detail::true_type);
+ get_set_load_imp(__gnu_pbds::detail::true_type);
void
- get_set_load_imp(pb_ds::detail::false_type);
+ get_set_load_imp(__gnu_pbds::detail::false_type);
bool
subscript();
bool
- subscript_imp(pb_ds::detail::false_type);
+ subscript_imp(__gnu_pbds::detail::false_type);
bool
- subscript_imp(pb_ds::detail::true_type);
+ subscript_imp(__gnu_pbds::detail::true_type);
bool
split_join();
bool
- split_join_imp(pb_ds::detail::false_type);
+ split_join_imp(__gnu_pbds::detail::false_type);
bool
- split_join_imp(pb_ds::detail::true_type);
+ split_join_imp(__gnu_pbds::detail::true_type);
void
cmp(const Cntnr&, const native_type&, const std::string&);
void
order_preserving_cmp_imp(const Cntnr&, const native_type&,
- pb_ds::detail::false_type);
+ __gnu_pbds::detail::false_type);
void
order_preserving_cmp_imp(const Cntnr&, const native_type&,
- pb_ds::detail::true_type);
+ __gnu_pbds::detail::true_type);
void
back_order_preserving_cmp_imp(const Cntnr&, const native_type&,
- pb_ds::detail::false_type);
+ __gnu_pbds::detail::false_type);
void
back_order_preserving_cmp_imp(const Cntnr&, const native_type&,
- pb_ds::detail::true_type);
+ __gnu_pbds::detail::true_type);
void
reverse_iteration_cmp_imp(const Cntnr&, const native_type&,
- pb_ds::detail::false_type);
+ __gnu_pbds::detail::false_type);
void
reverse_iteration_cmp_imp(const Cntnr&, const native_type&,
- pb_ds::detail::true_type);
+ __gnu_pbds::detail::true_type);
void
order_statistics_cmp_imp(const Cntnr&, const native_type&,
- pb_ds::detail::false_type);
+ __gnu_pbds::detail::false_type);
void
order_statistics_cmp_imp(const Cntnr&, const native_type&,
- pb_ds::detail::true_type);
+ __gnu_pbds::detail::true_type);
void
prefix_search_cmp_imp(const Cntnr&, const native_type&,
- pb_ds::detail::false_type);
+ __gnu_pbds::detail::false_type);
void
prefix_search_cmp_imp(const Cntnr&, const native_type&,
- pb_ds::detail::true_type);
+ __gnu_pbds::detail::true_type);
template<typename Const_It, class Const_Native_It>
void
void
lower_bound_cmp_imp(const Cntnr&, const native_type&,
- pb_ds::detail::false_type);
+ __gnu_pbds::detail::false_type);
void
lower_bound_cmp_imp(const Cntnr&, const native_type&,
- pb_ds::detail::true_type);
+ __gnu_pbds::detail::true_type);
void
upper_bound_cmp_imp(const Cntnr&, const native_type&,
- pb_ds::detail::false_type);
+ __gnu_pbds::detail::false_type);
void
upper_bound_cmp_imp(const Cntnr&, const native_type&,
- pb_ds::detail::true_type);
+ __gnu_pbds::detail::true_type);
void
print_container(const native_type&, std::ostream& r_os = std::cerr) const;
} // namespace detail
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
container_traits::order_preserving,
back_order_preserving =
container_traits::order_preserving&&
- !pb_ds::detail::is_same<
+ !__gnu_pbds::detail::is_same<
typename std::iterator_traits<
typename cntnr::const_iterator>::iterator_category,
std::forward_iterator_tag>::value,
reverse_iteration = container_traits::reverse_iteration,
order_statistics = test_traits::order_statistics,
prefix_search = test_traits::prefix_search,
- has_mapped = !pb_ds::detail::is_same<
+ has_mapped = !__gnu_pbds::detail::is_same<
typename Cntnr::mapped_type,
- pb_ds::null_mapped_type>::value
+ __gnu_pbds::null_mapped_type>::value
};
order_preserving_cmp_imp(r_c, r_native_c,
- pb_ds::detail::integral_constant<int,order_preserving>());
+ __gnu_pbds::detail::integral_constant<int,order_preserving>());
back_order_preserving_cmp_imp(r_c, r_native_c,
- pb_ds::detail::integral_constant<int,back_order_preserving>());
+ __gnu_pbds::detail::integral_constant<int,back_order_preserving>());
order_statistics_cmp_imp(r_c, r_native_c,
- pb_ds::detail::integral_constant<int,order_statistics>());
+ __gnu_pbds::detail::integral_constant<int,order_statistics>());
prefix_search_cmp_imp(r_c, r_native_c,
- pb_ds::detail::integral_constant<int,prefix_search>());
+ __gnu_pbds::detail::integral_constant<int,prefix_search>());
reverse_iteration_cmp_imp(r_c, r_native_c,
- pb_ds::detail::integral_constant<int,reverse_iteration>());
+ __gnu_pbds::detail::integral_constant<int,reverse_iteration>());
lower_bound_cmp_imp(r_c, r_native_c,
- pb_ds::detail::integral_constant<int,order_preserving>());
+ __gnu_pbds::detail::integral_constant<int,order_preserving>());
upper_bound_cmp_imp(r_c, r_native_c,
- pb_ds::detail::integral_constant<int,order_preserving>());
+ __gnu_pbds::detail::integral_constant<int,order_preserving>());
}
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
-order_preserving_cmp_imp(const Cntnr& /*r_c*/, const native_type& /*r_native_c*/, pb_ds::detail::false_type)
+order_preserving_cmp_imp(const Cntnr& /*r_c*/, const native_type& /*r_native_c*/, __gnu_pbds::detail::false_type)
{ }
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
-order_preserving_cmp_imp(const Cntnr& r_c, const native_type& r_native_c, pb_ds::detail::true_type)
+order_preserving_cmp_imp(const Cntnr& r_c, const native_type& r_native_c, __gnu_pbds::detail::true_type)
{
PB_DS_SET_DESTRUCT_PRINT
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
-back_order_preserving_cmp_imp(const Cntnr& /*r_c*/, const native_type& /*r_native_c*/, pb_ds::detail::false_type)
+back_order_preserving_cmp_imp(const Cntnr& /*r_c*/, const native_type& /*r_native_c*/, __gnu_pbds::detail::false_type)
{ }
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
-back_order_preserving_cmp_imp(const Cntnr& r_c, const native_type& r_native_c, pb_ds::detail::true_type)
+back_order_preserving_cmp_imp(const Cntnr& r_c, const native_type& r_native_c, __gnu_pbds::detail::true_type)
{
PB_DS_SET_DESTRUCT_PRINT
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
-reverse_iteration_cmp_imp(const Cntnr& /*r_c*/, const native_type& /*r_native_c*/, pb_ds::detail::false_type)
+reverse_iteration_cmp_imp(const Cntnr& /*r_c*/, const native_type& /*r_native_c*/, __gnu_pbds::detail::false_type)
{ }
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
-reverse_iteration_cmp_imp(const Cntnr& r_c, const native_type& r_native_c, pb_ds::detail::true_type)
+reverse_iteration_cmp_imp(const Cntnr& r_c, const native_type& r_native_c, __gnu_pbds::detail::true_type)
{
PB_DS_SET_DESTRUCT_PRINT
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
-order_statistics_cmp_imp(const Cntnr& /*r_c*/, const native_type& /*r_native_c*/, pb_ds::detail::false_type)
+order_statistics_cmp_imp(const Cntnr& /*r_c*/, const native_type& /*r_native_c*/, __gnu_pbds::detail::false_type)
{ }
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
-order_statistics_cmp_imp(const Cntnr& r_c, const native_type& r_native_c, pb_ds::detail::true_type)
+order_statistics_cmp_imp(const Cntnr& r_c, const native_type& r_native_c, __gnu_pbds::detail::true_type)
{
{
m_alloc.set_throw_prob(0);
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
-prefix_search_cmp_imp(const Cntnr& /*r_c*/, const native_type& /*r_native_c*/, pb_ds::detail::false_type)
+prefix_search_cmp_imp(const Cntnr& /*r_c*/, const native_type& /*r_native_c*/, __gnu_pbds::detail::false_type)
{ }
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
-prefix_search_cmp_imp(const Cntnr& r_c, const native_type& r_native_c, pb_ds::detail::true_type)
+prefix_search_cmp_imp(const Cntnr& r_c, const native_type& r_native_c, __gnu_pbds::detail::true_type)
{
PB_DS_SET_DESTRUCT_PRINT
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
-lower_bound_cmp_imp(const Cntnr& /*r_c*/, const native_type& /*r_native_c*/, pb_ds::detail::false_type)
+lower_bound_cmp_imp(const Cntnr& /*r_c*/, const native_type& /*r_native_c*/, __gnu_pbds::detail::false_type)
{ }
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
-lower_bound_cmp_imp(const Cntnr& r_c, const native_type& r_native_c, pb_ds::detail::true_type)
+lower_bound_cmp_imp(const Cntnr& r_c, const native_type& r_native_c, __gnu_pbds::detail::true_type)
{
PB_DS_SET_DESTRUCT_PRINT
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
-upper_bound_cmp_imp(const Cntnr& /*r_c*/, const native_type& /*r_native_c*/, pb_ds::detail::false_type)
+upper_bound_cmp_imp(const Cntnr& /*r_c*/, const native_type& /*r_native_c*/, __gnu_pbds::detail::false_type)
{ }
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
-upper_bound_cmp_imp(const Cntnr& r_c, const native_type& r_native_c, pb_ds::detail::true_type)
+upper_bound_cmp_imp(const Cntnr& r_c, const native_type& r_native_c, __gnu_pbds::detail::true_type)
{
PB_DS_SET_DESTRUCT_PRINT
PB_DS_CLASS_T_DEC
bool
PB_DS_CLASS_C_DEC::
-it_constructor_imp(pb_ds::cc_hash_tag)
+it_constructor_imp(__gnu_pbds::cc_hash_tag)
{
bool done = true;
Cntnr* p_c = NULL;
PB_DS_CLASS_T_DEC
bool
PB_DS_CLASS_C_DEC::
-it_constructor_imp(pb_ds::gp_hash_tag)
+it_constructor_imp(__gnu_pbds::gp_hash_tag)
{
bool done = true;
Cntnr* p_c = NULL;
PB_DS_CLASS_T_DEC
bool
PB_DS_CLASS_C_DEC::
-it_constructor_imp(pb_ds::tree_tag)
+it_constructor_imp(__gnu_pbds::tree_tag)
{
bool done = true;
Cntnr* p_c = NULL;
PB_DS_CLASS_T_DEC
bool
PB_DS_CLASS_C_DEC::
-it_constructor_imp(pb_ds::list_update_tag)
+it_constructor_imp(__gnu_pbds::list_update_tag)
{
bool done = true;
Cntnr* p_c = NULL;
PB_DS_CLASS_T_DEC
bool
PB_DS_CLASS_C_DEC::
-it_constructor_imp(pb_ds::pat_trie_tag)
+it_constructor_imp(__gnu_pbds::pat_trie_tag)
{
bool done = true;
Cntnr* p_c = NULL;
iterator_defs();
- node_iterator_defs(pb_ds::detail::integral_constant<int,
+ node_iterator_defs(__gnu_pbds::detail::integral_constant<int,
container_traits::order_preserving>());
policy_defs();
PB_DS_CLASS_C_DEC::
ds_defs()
{
- typedef pb_ds::container_traits< Cntnr> test_container_traits;
+ typedef __gnu_pbds::container_traits< Cntnr> test_container_traits;
typedef typename test_container_traits::container_category test_container_category;
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
-node_iterator_defs(pb_ds::detail::false_type)
+node_iterator_defs(__gnu_pbds::detail::false_type)
{ }
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
-node_iterator_defs(pb_ds::detail::true_type)
+node_iterator_defs(__gnu_pbds::detail::true_type)
{
typedef typename Cntnr::node_iterator test_node_iterator;
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
-policy_defs(pb_ds::basic_hash_tag)
+policy_defs(__gnu_pbds::basic_hash_tag)
{
typedef typename Cntnr::hash_fn test_hash_fn;
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
-policy_defs(pb_ds::cc_hash_tag)
+policy_defs(__gnu_pbds::cc_hash_tag)
{
- policy_defs(pb_ds::basic_hash_tag());
+ policy_defs(__gnu_pbds::basic_hash_tag());
typedef typename Cntnr::comb_hash_fn test_comb_hash_fn;
}
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
-policy_defs(pb_ds::gp_hash_tag)
+policy_defs(__gnu_pbds::gp_hash_tag)
{
- policy_defs(pb_ds::basic_hash_tag());
+ policy_defs(__gnu_pbds::basic_hash_tag());
typedef typename Cntnr::comb_probe_fn test_comb_probe_fn;
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
-policy_defs(pb_ds::tree_tag)
+policy_defs(__gnu_pbds::tree_tag)
{
typedef typename Cntnr::cmp_fn test_cmp_fn;
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
-policy_defs(pb_ds::list_update_tag)
+policy_defs(__gnu_pbds::list_update_tag)
{
typedef typename Cntnr::eq_fn test_eq_fn;
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
-policy_defs(pb_ds::pat_trie_tag)
+policy_defs(__gnu_pbds::pat_trie_tag)
{
typedef typename Cntnr::e_access_traits e_access_traits;
}
container_traits::order_preserving
};
- return (erase_it_imp(pb_ds::detail::integral_constant<int,erase_iterators>()));
+ return (erase_it_imp(__gnu_pbds::detail::integral_constant<int,erase_iterators>()));
}
PB_DS_CLASS_T_DEC
bool
PB_DS_CLASS_C_DEC::
-erase_it_imp(pb_ds::detail::false_type)
+erase_it_imp(__gnu_pbds::detail::false_type)
{
return (true);
}
PB_DS_CLASS_T_DEC
bool
PB_DS_CLASS_C_DEC::
-erase_it_imp(pb_ds::detail::true_type)
+erase_it_imp(__gnu_pbds::detail::true_type)
{
PB_DS_TRACE("erase_it");
m_native_c.erase(native_it);
bool range_guarantee =
- pb_ds::detail::is_same<
+ __gnu_pbds::detail::is_same<
typename container_traits::invalidation_guarantee,
- pb_ds::range_invalidation_guarantee>::value ;
+ __gnu_pbds::range_invalidation_guarantee>::value ;
if (range_guarantee)
PB_DS_THROW_IF_FAILED( next_ers_it == next_it, "", m_p_c, & m_native_c);
container_traits::reverse_iteration
};
- return (erase_rev_it_imp(pb_ds::detail::integral_constant<int,erase_iterators>()));
+ return (erase_rev_it_imp(__gnu_pbds::detail::integral_constant<int,erase_iterators>()));
}
PB_DS_CLASS_T_DEC
bool
PB_DS_CLASS_C_DEC::
-erase_rev_it_imp(pb_ds::detail::false_type)
+erase_rev_it_imp(__gnu_pbds::detail::false_type)
{
return (true);
}
PB_DS_CLASS_T_DEC
bool
PB_DS_CLASS_C_DEC::
-erase_rev_it_imp(pb_ds::detail::true_type)
+erase_rev_it_imp(__gnu_pbds::detail::true_type)
{
PB_DS_TRACE("erase_rev_it");
get_set_load()
{
typedef
- pb_ds::detail::integral_constant<int,
+ __gnu_pbds::detail::integral_constant<int,
test_traits::get_set_load>
get_set_load_ind;
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
-get_set_load_imp(pb_ds::detail::false_type)
+get_set_load_imp(__gnu_pbds::detail::false_type)
{ }
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
-get_set_load_imp(pb_ds::detail::true_type)
+get_set_load_imp(__gnu_pbds::detail::true_type)
{
PB_DS_TRACE("get_set_load");
get_set_loads()
{
typedef
- pb_ds::detail::integral_constant<int,
+ __gnu_pbds::detail::integral_constant<int,
test_traits::get_set_loads>
get_set_loads_ind;
PB_DS_CLASS_T_DEC
bool
PB_DS_CLASS_C_DEC::
-get_set_loads_imp(pb_ds::detail::false_type)
+get_set_loads_imp(__gnu_pbds::detail::false_type)
{
return (true);
}
PB_DS_CLASS_T_DEC
bool
PB_DS_CLASS_C_DEC::
-get_set_loads_imp(pb_ds::detail::true_type)
+get_set_loads_imp(__gnu_pbds::detail::true_type)
{
PB_DS_TRACE("get_set_loads");
{
done = false;
}
- catch(pb_ds::insert_error&)
+ catch(__gnu_pbds::insert_error&)
{
PB_DS_THROW_IF_FAILED(false, "", m_p_c, &m_native_c);
}
reverse_iteration = container_traits::reverse_iteration
};
- rev_it_copy_imp(pb_ds::detail::integral_constant<int,reverse_iteration>());
+ rev_it_copy_imp(__gnu_pbds::detail::integral_constant<int,reverse_iteration>());
}
PB_DS_CLASS_T_DEC
reverse_iteration = container_traits::reverse_iteration
};
- rev_it_assign_imp(pb_ds::detail::integral_constant<int,reverse_iteration>());
+ rev_it_assign_imp(__gnu_pbds::detail::integral_constant<int,reverse_iteration>());
}
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
-rev_it_copy_imp(pb_ds::detail::false_type)
+rev_it_copy_imp(__gnu_pbds::detail::false_type)
{ }
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
-rev_it_copy_imp(pb_ds::detail::true_type)
+rev_it_copy_imp(__gnu_pbds::detail::true_type)
{
{
typename cntnr::iterator it = m_p_c->end();
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
-rev_it_assign_imp(pb_ds::detail::false_type)
+rev_it_assign_imp(__gnu_pbds::detail::false_type)
{ }
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
-rev_it_assign_imp(pb_ds::detail::true_type)
+rev_it_assign_imp(__gnu_pbds::detail::true_type)
{
{
typename cntnr::iterator it = m_p_c->end();
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
-policy_access(pb_ds::basic_hash_tag)
+policy_access(__gnu_pbds::basic_hash_tag)
{
{
typename Cntnr::hash_fn& r_t =
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
-policy_access(pb_ds::cc_hash_tag)
+policy_access(__gnu_pbds::cc_hash_tag)
{
- policy_access(pb_ds::basic_hash_tag());
+ policy_access(__gnu_pbds::basic_hash_tag());
{
typename Cntnr::comb_hash_fn& r_t =
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
-policy_access(pb_ds::gp_hash_tag)
+policy_access(__gnu_pbds::gp_hash_tag)
{
- policy_access(pb_ds::basic_hash_tag());
+ policy_access(__gnu_pbds::basic_hash_tag());
{
typename Cntnr::comb_probe_fn& r_t =
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
-policy_access(pb_ds::tree_tag)
+policy_access(__gnu_pbds::tree_tag)
{
{
typename Cntnr::cmp_fn& r_t =
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
-policy_access(pb_ds::list_update_tag)
+policy_access(__gnu_pbds::list_update_tag)
{ }
PB_DS_CLASS_T_DEC
void
PB_DS_CLASS_C_DEC::
-policy_access(pb_ds::pat_trie_tag)
+policy_access(__gnu_pbds::pat_trie_tag)
{
typename Cntnr::e_access_traits& r_t =
m_p_c->get_e_access_traits();
PB_DS_CLASS_C_DEC::
resize()
{
- typedef pb_ds::detail::integral_constant<int, test_traits::resize> resize_ind;
+ typedef __gnu_pbds::detail::integral_constant<int, test_traits::resize> resize_ind;
return (resize_imp(resize_ind()));
}
PB_DS_CLASS_T_DEC
bool
PB_DS_CLASS_C_DEC::
-resize_imp(pb_ds::detail::false_type)
+resize_imp(__gnu_pbds::detail::false_type)
{
return (true);
}
PB_DS_CLASS_T_DEC
bool
PB_DS_CLASS_C_DEC::
-resize_imp(pb_ds::detail::true_type)
+resize_imp(__gnu_pbds::detail::true_type)
{
PB_DS_TRACE("resize");
split_join = container_traits::order_preserving
};
- return (split_join_imp(pb_ds::detail::integral_constant<int,split_join>()));
+ return (split_join_imp(__gnu_pbds::detail::integral_constant<int,split_join>()));
}
PB_DS_CLASS_T_DEC
bool
PB_DS_CLASS_C_DEC::
-split_join_imp(pb_ds::detail::false_type)
+split_join_imp(__gnu_pbds::detail::false_type)
{
return (true);
}
PB_DS_CLASS_T_DEC
bool
PB_DS_CLASS_C_DEC::
-split_join_imp(pb_ds::detail::true_type)
+split_join_imp(__gnu_pbds::detail::true_type)
{
PB_DS_TRACE("split_join");
enum
{
- no_data = pb_ds::detail::is_same<
+ no_data = __gnu_pbds::detail::is_same<
typename Cntnr::const_key_reference,
typename Cntnr::const_reference>::value
};
- return (subscript_imp(pb_ds::detail::integral_constant<int,no_data>()));
+ return (subscript_imp(__gnu_pbds::detail::integral_constant<int,no_data>()));
}
PB_DS_CLASS_T_DEC
bool
PB_DS_CLASS_C_DEC::
-subscript_imp(pb_ds::detail::false_type)
+subscript_imp(__gnu_pbds::detail::false_type)
{
bool done = true;
PB_DS_CLASS_T_DEC
bool
PB_DS_CLASS_C_DEC::
-subscript_imp(pb_ds::detail::true_type)
+subscript_imp(__gnu_pbds::detail::true_type)
{
bool done = true;
value_type v = test_traits::generate_value(m_g, m_m);
m_alloc.set_throw_prob(m_tp);
- (*m_p_c)[v] = pb_ds::null_mapped_type();
+ (*m_p_c)[v] = __gnu_pbds::null_mapped_type();
m_native_c.insert(test_traits::native_value(v));
}
#include <regression/basic_type.hpp>
#include <regression/assoc/common_type.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
{
detail::verify_params(sd, n, m, tp, ip, ep, cp, mp, disp);
}
- catch (pb_ds::test::illegal_input_error&)
+ catch (__gnu_pbds::test::illegal_input_error&)
{
detail::usage(name);
return -1;
}
} // namespace detail
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <regression/rand/io/xml_formatter.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_XML_TEST_REGRESSION_FORMATTER_HPP
#include <regression/rand/io/xml_formatter.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_XML_TEST_REGRESSION_FORMATTER_HPP
#include <iostream>
#include <io/xml_test_formatter.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_COMMON_XML_TEST_REGRESSION_FORMATTER_HPP
#include <regression/rand/io/priority_queue/xml_formatter.hpp>
#include <regression/trait/priority_queue/trait.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_CONTAINER_RAND_REGRESSION_TEST_HPP
{
done = false;
- PB_DS_THROW_IF_FAILED( pb_ds::container_traits<cntnr>::split_join_can_throw, pb_ds::container_traits<cntnr>::split_join_can_throw, m_p_c, & m_native_c);
+ PB_DS_THROW_IF_FAILED( __gnu_pbds::container_traits<cntnr>::split_join_can_throw, __gnu_pbds::container_traits<cntnr>::split_join_can_throw, m_p_c, & m_native_c);
}
PB_DS_COND_COMPARE(*m_p_c, m_native_c);
#include <regression/basic_type.hpp>
#include <regression/priority_queue/common_type.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
{
detail::verify_params(sd, n, m, tp, ip, dp, ep, cp, mp, disp);
}
- catch(pb_ds::test::illegal_input_error&)
+ catch(__gnu_pbds::test::illegal_input_error&)
{
detail::usage(name);
return -1;
}
} // namespace detail
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <ext/pb_ds/assoc_container.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
template<typename Cntnr>
struct regression_test_get_set_load_traits<
Cntnr,
- pb_ds::cc_hash_tag> : public regression_test_hash_get_set_load_traits<
+ __gnu_pbds::cc_hash_tag> : public regression_test_hash_get_set_load_traits<
Cntnr>
{ };
template<typename Cntnr>
struct regression_test_get_set_load_traits<
Cntnr,
- pb_ds::gp_hash_tag> : public regression_test_hash_get_set_load_traits<
+ __gnu_pbds::gp_hash_tag> : public regression_test_hash_get_set_load_traits<
Cntnr>
{ };
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_REGRESSION_TEST_SET_LOAD_TRAIT_HPP
#include <ext/pb_ds/assoc_container.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
template<typename Cntnr>
struct regression_test_get_set_loacontainer_traits<
Cntnr,
- pb_ds::cc_hash_tag> : public regression_test_hash_get_set_loacontainer_traits<
+ __gnu_pbds::cc_hash_tag> : public regression_test_hash_get_set_loacontainer_traits<
Cntnr>
{ };
template<typename Cntnr>
struct regression_test_get_set_loacontainer_traits<
Cntnr,
- pb_ds::gp_hash_tag> : public regression_test_hash_get_set_loacontainer_traits<
+ __gnu_pbds::gp_hash_tag> : public regression_test_hash_get_set_loacontainer_traits<
Cntnr>
{ };
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_REGRESSION_TEST_SET_LOADS_TRAIT_HPP
#ifndef PB_DS_REGRESSION_TEST_NATIVE_TYPE_TRAIT_HPP
#define PB_DS_REGRESSION_TEST_NATIVE_TYPE_TRAIT_HPP
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
struct native_type_traits_base<
Native_Key_Type,
Key_Type,
- pb_ds::null_mapped_type,
+ __gnu_pbds::null_mapped_type,
Allocator>
{
public:
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_REGRESSION_TEST_NATIVE_TYPE_TRAIT_HPP
#include <common_type/assoc/detail/trie_supports_order_statistics.hpp>
#include <common_type/assoc/detail/trie_supports_prefix_search.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
template<typename Cntnr>
struct regression_test_node_update_traits<
Cntnr,
- pb_ds::pat_trie_tag>
+ __gnu_pbds::pat_trie_tag>
{
enum
{
template<typename Cntnr>
struct regression_test_node_update_traits<
Cntnr,
- pb_ds::rb_tree_tag>
+ __gnu_pbds::rb_tree_tag>
{
enum
{
template<typename Cntnr>
struct regression_test_node_update_traits<
Cntnr,
- pb_ds::splay_tree_tag>
+ __gnu_pbds::splay_tree_tag>
{
enum
{
template<typename Cntnr>
struct regression_test_node_update_traits<
Cntnr,
- pb_ds::ov_tree_tag>
+ __gnu_pbds::ov_tree_tag>
{
enum
{
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_REGRESSION_TEST_NODE_UPDATOR_TRAIT_HPP
#include <ext/pb_ds/assoc_container.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
template<typename Cntnr>
struct regression_test_resize_traits<
Cntnr,
- pb_ds::cc_hash_tag> : public regression_test_hash_resize_traits<
+ __gnu_pbds::cc_hash_tag> : public regression_test_hash_resize_traits<
Cntnr>
{ };
template<typename Cntnr>
struct regression_test_resize_traits<
Cntnr,
- pb_ds::gp_hash_tag> : public regression_test_hash_resize_traits<
+ __gnu_pbds::gp_hash_tag> : public regression_test_hash_resize_traits<
Cntnr>
{ };
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_REGRESSION_TEST_RESIZE_TRAIT_HPP
#include <regression/basic_type.hpp>
#include <string>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_REGRESSION_TEST_TO_STRING_HPP
#include <regression/trait/assoc/node_update_trait.hpp>
#include <regression/trait/erase_if_fn.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
} // namespace detail
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <regression/basic_type.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
template<typename Gen>
static value_type
- generate_value(Gen& r_gen, size_t max, pb_ds::null_mapped_type)
+ generate_value(Gen& r_gen, size_t max, __gnu_pbds::null_mapped_type)
{ return basic_type(r_gen, max); }
template<typename Gen>
};
} // namespace detail
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <functional>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
};
} // namespace detail
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <regression/trait/erase_if_fn.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
{
typedef typename Cntnr::value_type value_type;
typedef typename Cntnr::const_reference const_reference;
- typedef pb_ds::test::native_priority_queue<std::string, true> native_type;
+ typedef __gnu_pbds::test::native_priority_queue<std::string, true> native_type;
typedef typename native_type::value_type native_value_type;
template<typename T>
};
} // namespace detail
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <debug/debug.h>
#include <util/rng/twister_rand_gen.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
return ret;
}
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#include <limits.h>
#include <tr1/random>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
base_generator_t m_base_generator;
};
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif // #ifndef PB_DS_TWISTER_RAND_GEN_HPP
#include <statistic/sample_variance.hpp>
#include <statistic/sample_mean_confidence_checker.hpp>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
}
} // namespace detail
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <math.h>
#include <iterator>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
} // namespace detail
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <numeric>
#include <math.h>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
}
} // namespace detail
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
#include <math.h>
#include <iterator>
-namespace pb_ds
+namespace __gnu_pbds
{
namespace test
{
} // namespace detail
} // namespace test
-} // namespace pb_ds
+} // namespace __gnu_pbds
#endif
projects / gcc.git / commitdiff