diff options
Diffstat (limited to 'gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_')
8 files changed, 1006 insertions, 0 deletions
diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/constructors_destructor_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/constructors_destructor_fn_imps.hpp new file mode 100644 index 0000000..a563445 --- /dev/null +++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/constructors_destructor_fn_imps.hpp @@ -0,0 +1,84 @@ +// -*- C++ -*- + +// Copyright (C) 2005-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License as published by the Free Software +// Foundation; either version 3, or (at your option) any later +// version. + +// This library is distributed in the hope that it will be useful, but +// WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL. + +// Permission to use, copy, modify, sell, and distribute this software +// is hereby granted without fee, provided that the above copyright +// notice appears in all copies, and that both that copyright notice +// and this permission notice appear in supporting documentation. None +// of the above authors, nor IBM Haifa Research Laboratories, make any +// representation about the suitability of this software for any +// purpose. It is provided "as is" without express or implied +// warranty. + +/** + * @file rc_binomial_heap_/constructors_destructor_fn_imps.hpp + * Contains an implementation for rc_binomial_heap_. + */ + +PB_DS_CLASS_T_DEC +PB_DS_CLASS_C_DEC:: +rc_binomial_heap() +{ + PB_DS_ASSERT_VALID((*this)) +} + +PB_DS_CLASS_T_DEC +PB_DS_CLASS_C_DEC:: +rc_binomial_heap(const Cmp_Fn& r_cmp_fn) +: base_type(r_cmp_fn) +{ + PB_DS_ASSERT_VALID((*this)) +} + +PB_DS_CLASS_T_DEC +PB_DS_CLASS_C_DEC:: +rc_binomial_heap(const PB_DS_CLASS_C_DEC& other) +: base_type(other) +{ + make_binomial_heap(); + base_type::find_max(); + PB_DS_ASSERT_VALID((*this)) +} + +PB_DS_CLASS_T_DEC +PB_DS_CLASS_C_DEC:: +~rc_binomial_heap() +{ } + +PB_DS_CLASS_T_DEC +void +PB_DS_CLASS_C_DEC:: +swap(PB_DS_CLASS_C_DEC& other) +{ + PB_DS_ASSERT_VALID((*this)) + PB_DS_ASSERT_VALID(other) + + base_type::swap(other); + m_rc.swap(other.m_rc); + + PB_DS_ASSERT_VALID((*this)) + PB_DS_ASSERT_VALID(other) +} diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/debug_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/debug_fn_imps.hpp new file mode 100644 index 0000000..d42f418 --- /dev/null +++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/debug_fn_imps.hpp @@ -0,0 +1,121 @@ +// -*- C++ -*- + +// Copyright (C) 2005-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License as published by the Free Software +// Foundation; either version 3, or (at your option) any later +// version. + +// This library is distributed in the hope that it will be useful, but +// WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL. + +// Permission to use, copy, modify, sell, and distribute this software +// is hereby granted without fee, provided that the above copyright +// notice appears in all copies, and that both that copyright notice +// and this permission notice appear in supporting documentation. None +// of the above authors, nor IBM Haifa Research Laboratories, make any +// representation about the suitability of this software for any +// purpose. It is provided "as is" without express or implied +// warranty. + +/** + * @file rc_binomial_heap_/debug_fn_imps.hpp + * Contains an implementation for rc_binomial_heap_. + */ + +#ifdef _GLIBCXX_DEBUG + +PB_DS_CLASS_T_DEC +void +PB_DS_CLASS_C_DEC:: +assert_valid(const char* __file, int __line) const +{ + base_type::assert_valid(false, __file, __line); + if (!base_type::empty()) + { + PB_DS_DEBUG_VERIFY(base_type::m_p_max != 0); + base_type::assert_max(__file, __line); + } + + m_rc.assert_valid(__file, __line); + + if (m_rc.empty()) + { + base_type::assert_valid(true, __file, __line); + PB_DS_DEBUG_VERIFY(next_2_pointer(base_type::m_p_root) == 0); + return; + } + + node_const_pointer p_nd = next_2_pointer(base_type::m_p_root); + typename rc_t::const_iterator it = m_rc.end(); + --it; + + while (p_nd != 0) + { + PB_DS_DEBUG_VERIFY(*it == p_nd); + node_const_pointer p_next = p_nd->m_p_next_sibling; + PB_DS_DEBUG_VERIFY(p_next != 0); + PB_DS_DEBUG_VERIFY(p_nd->m_metadata == p_next->m_metadata); + PB_DS_DEBUG_VERIFY(p_next->m_p_next_sibling == 0 || + p_next->m_metadata < p_next->m_p_next_sibling->m_metadata); + + --it; + p_nd = next_2_pointer(next_after_0_pointer(p_nd)); + } + PB_DS_DEBUG_VERIFY(it + 1 == m_rc.begin()); +} + +PB_DS_CLASS_T_DEC +typename PB_DS_CLASS_C_DEC::node_const_pointer +PB_DS_CLASS_C_DEC:: +next_2_pointer(node_const_pointer p_nd) +{ + if (p_nd == 0) + return 0; + + node_pointer p_next = p_nd->m_p_next_sibling; + + if (p_next == 0) + return 0; + + if (p_nd->m_metadata == p_next->m_metadata) + return p_nd; + + return next_2_pointer(p_next); +} + +PB_DS_CLASS_T_DEC +typename PB_DS_CLASS_C_DEC::node_const_pointer +PB_DS_CLASS_C_DEC:: +next_after_0_pointer(node_const_pointer p_nd) +{ + if (p_nd == 0) + return 0; + + node_pointer p_next = p_nd->m_p_next_sibling; + + if (p_next == 0) + return 0; + + if (p_nd->m_metadata < p_next->m_metadata) + return p_next; + + return next_after_0_pointer(p_next); +} + +#endif diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/erase_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/erase_fn_imps.hpp new file mode 100644 index 0000000..2d6a6e1 --- /dev/null +++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/erase_fn_imps.hpp @@ -0,0 +1,107 @@ +// -*- C++ -*- + +// Copyright (C) 2005-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License as published by the Free Software +// Foundation; either version 3, or (at your option) any later +// version. + +// This library is distributed in the hope that it will be useful, but +// WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL. + +// Permission to use, copy, modify, sell, and distribute this software +// is hereby granted without fee, provided that the above copyright +// notice appears in all copies, and that both that copyright notice +// and this permission notice appear in supporting documentation. None +// of the above authors, nor IBM Haifa Research Laboratories, make any +// representation about the suitability of this software for any +// purpose. It is provided "as is" without express or implied +// warranty. + +/** + * @file rc_binomial_heap_/erase_fn_imps.hpp + * Contains an implementation for rc_binomial_heap_. + */ + +PB_DS_CLASS_T_DEC +inline void +PB_DS_CLASS_C_DEC:: +pop() +{ + make_binomial_heap(); + _GLIBCXX_DEBUG_ASSERT(!base_type::empty()); + base_type::pop(); + base_type::find_max(); +} + +PB_DS_CLASS_T_DEC +void +PB_DS_CLASS_C_DEC:: +clear() +{ + base_type::clear(); + m_rc.clear(); +} + +PB_DS_CLASS_T_DEC +void +PB_DS_CLASS_C_DEC:: +make_binomial_heap() +{ + node_pointer p_nd = base_type::m_p_root; + while (p_nd != 0) + { + node_pointer p_next = p_nd->m_p_next_sibling; + if (p_next == 0) + p_nd = p_next; + else if (p_nd->m_metadata == p_next->m_metadata) + p_nd = link_with_next_sibling(p_nd); + else if (p_nd->m_metadata < p_next->m_metadata) + p_nd = p_next; +#ifdef _GLIBCXX_DEBUG + else + _GLIBCXX_DEBUG_ASSERT(0); +#endif + } + + m_rc.clear(); +} + +PB_DS_CLASS_T_DEC +template<typename Pred> +typename PB_DS_CLASS_C_DEC::size_type +PB_DS_CLASS_C_DEC:: +erase_if(Pred pred) +{ + make_binomial_heap(); + const size_type ersd = base_type::erase_if(pred); + base_type::find_max(); + PB_DS_ASSERT_VALID((*this)) + return ersd; +} + +PB_DS_CLASS_T_DEC +void +PB_DS_CLASS_C_DEC:: +erase(point_iterator it) +{ + make_binomial_heap(); + base_type::erase(it); + base_type::find_max(); +} + diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/insert_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/insert_fn_imps.hpp new file mode 100644 index 0000000..35ae5a0 --- /dev/null +++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/insert_fn_imps.hpp @@ -0,0 +1,154 @@ +// -*- C++ -*- + +// Copyright (C) 2005-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License as published by the Free Software +// Foundation; either version 3, or (at your option) any later +// version. + +// This library is distributed in the hope that it will be useful, but +// WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL. + +// Permission to use, copy, modify, sell, and distribute this software +// is hereby granted without fee, provided that the above copyright +// notice appears in all copies, and that both that copyright notice +// and this permission notice appear in supporting documentation. None +// of the above authors, nor IBM Haifa Research Laboratories, make any +// representation about the suitability of this software for any +// purpose. It is provided "as is" without express or implied +// warranty. + +/** + * @file rc_binomial_heap_/insert_fn_imps.hpp + * Contains an implementation for rc_binomial_heap_. + */ + +PB_DS_CLASS_T_DEC +inline typename PB_DS_CLASS_C_DEC::point_iterator +PB_DS_CLASS_C_DEC:: +push(const_reference r_val) +{ + PB_DS_ASSERT_VALID((*this)) + + make_0_exposed(); + + PB_DS_ASSERT_VALID((*this)) + + node_pointer p_nd = base_type::get_new_node_for_insert(r_val); + + p_nd->m_p_l_child = p_nd->m_p_prev_or_parent = 0; + p_nd->m_metadata = 0; + + if (base_type::m_p_max == 0 || Cmp_Fn::operator()(base_type::m_p_max->m_value, r_val)) + base_type::m_p_max = p_nd; + + p_nd->m_p_next_sibling = base_type::m_p_root; + + if (base_type::m_p_root != 0) + base_type::m_p_root->m_p_prev_or_parent = p_nd; + + base_type::m_p_root = p_nd; + + if (p_nd->m_p_next_sibling != 0&& p_nd->m_p_next_sibling->m_metadata == 0) + m_rc.push(p_nd); + + PB_DS_ASSERT_VALID((*this)) + + return point_iterator(p_nd); +} + +PB_DS_CLASS_T_DEC +void +PB_DS_CLASS_C_DEC:: +modify(point_iterator it, const_reference r_new_val) +{ + PB_DS_ASSERT_VALID((*this)) + + make_binomial_heap(); + + base_type::modify(it, r_new_val); + + base_type::find_max(); + + PB_DS_ASSERT_VALID((*this)) +} + +PB_DS_CLASS_T_DEC +inline typename PB_DS_CLASS_C_DEC::node_pointer +PB_DS_CLASS_C_DEC:: +link_with_next_sibling(node_pointer p_nd) +{ + node_pointer p_next = p_nd->m_p_next_sibling; + + _GLIBCXX_DEBUG_ASSERT(p_next != 0); + _GLIBCXX_DEBUG_ASSERT(p_next->m_p_prev_or_parent == p_nd); + + if (Cmp_Fn::operator()(p_nd->m_value, p_next->m_value)) + { + p_next->m_p_prev_or_parent = p_nd->m_p_prev_or_parent; + + if (p_next->m_p_prev_or_parent == 0) + base_type::m_p_root = p_next; + else + p_next->m_p_prev_or_parent->m_p_next_sibling = p_next; + + if (base_type::m_p_max == p_nd) + base_type::m_p_max = p_next; + + base_type::make_child_of(p_nd, p_next); + + ++p_next->m_metadata; + + return p_next; + } + + p_nd->m_p_next_sibling = p_next->m_p_next_sibling; + + if (p_nd->m_p_next_sibling != 0) + p_nd->m_p_next_sibling->m_p_prev_or_parent = p_nd; + + if (base_type::m_p_max == p_next) + base_type::m_p_max = p_nd; + + base_type::make_child_of(p_next, p_nd); + + ++p_nd->m_metadata; + + return p_nd; +} + +PB_DS_CLASS_T_DEC +void +PB_DS_CLASS_C_DEC:: +make_0_exposed() +{ + if (m_rc.empty()) + return; + + node_pointer p_nd = m_rc.top(); + + m_rc.pop(); + + _GLIBCXX_DEBUG_ASSERT(p_nd->m_p_next_sibling != 0); + _GLIBCXX_DEBUG_ASSERT(p_nd->m_metadata == p_nd->m_p_next_sibling->m_metadata); + + node_pointer p_res = link_with_next_sibling(p_nd); + + if (p_res->m_p_next_sibling != 0&& p_res->m_metadata == p_res->m_p_next_sibling->m_metadata) + m_rc.push(p_res); +} diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/rc.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/rc.hpp new file mode 100644 index 0000000..eaf8f48 --- /dev/null +++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/rc.hpp @@ -0,0 +1,240 @@ +// -*- C++ -*- + +// Copyright (C) 2005-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License as published by the Free Software +// Foundation; either version 3, or (at your option) any later +// version. + +// This library is distributed in the hope that it will be useful, but +// WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL. + +// Permission to use, copy, modify, sell, and distribute this software +// is hereby granted without fee, provided that the above copyright +// notice appears in all copies, and that both that copyright notice +// and this permission notice appear in supporting documentation. None +// of the above authors, nor IBM Haifa Research Laboratories, make any +// representation about the suitability of this software for any +// purpose. It is provided "as is" without express or implied +// warranty. + +/** + * @file rc_binomial_heap_/rc.hpp + * Contains a redundant (binary counter). + */ + +#ifndef PB_DS_RC_HPP +#define PB_DS_RC_HPP + +namespace __gnu_pbds +{ + namespace detail + { + /// Redundant binary counter. + template<typename _Node, typename _Alloc> + class rc + { + private: + typedef _Alloc allocator_type; + typedef typename allocator_type::size_type size_type; + typedef _Node node; + + typedef typename _Alloc::template rebind<node> __rebind_n; + typedef typename __rebind_n::other::pointer node_pointer; + + typedef typename _Alloc::template rebind<node_pointer> __rebind_np; + + typedef typename __rebind_np::other::pointer entry_pointer; + typedef typename __rebind_np::other::const_pointer entry_const_pointer; + + enum + { + max_entries = sizeof(size_type) << 3 + }; + + public: + typedef node_pointer entry; + typedef entry_const_pointer const_iterator; + + rc(); + + rc(const rc&); + + inline void + swap(rc&); + + inline void + push(entry); + + inline node_pointer + top() const; + + inline void + pop(); + + inline bool + empty() const; + + inline size_type + size() const; + + void + clear(); + + const const_iterator + begin() const; + + const const_iterator + end() const; + +#ifdef _GLIBCXX_DEBUG + void + assert_valid(const char*, int) const; +#endif + +#ifdef PB_DS_RC_BINOMIAL_HEAP_TRACE_ + void + trace() const; +#endif + + private: + node_pointer m_a_entries[max_entries]; + size_type m_over_top; + }; + + template<typename _Node, typename _Alloc> + rc<_Node, _Alloc>:: + rc() : m_over_top(0) + { PB_DS_ASSERT_VALID((*this)) } + + template<typename _Node, typename _Alloc> + rc<_Node, _Alloc>:: + rc(const rc<_Node, _Alloc>& other) : m_over_top(0) + { PB_DS_ASSERT_VALID((*this)) } + + template<typename _Node, typename _Alloc> + inline void + rc<_Node, _Alloc>:: + swap(rc<_Node, _Alloc>& other) + { + PB_DS_ASSERT_VALID((*this)) + PB_DS_ASSERT_VALID(other) + + const size_type over_top = std::max(m_over_top, other.m_over_top); + + for (size_type i = 0; i < over_top; ++i) + std::swap(m_a_entries[i], other.m_a_entries[i]); + + std::swap(m_over_top, other.m_over_top); + PB_DS_ASSERT_VALID((*this)) + PB_DS_ASSERT_VALID(other) + } + + template<typename _Node, typename _Alloc> + inline void + rc<_Node, _Alloc>:: + push(entry p_nd) + { + PB_DS_ASSERT_VALID((*this)) + _GLIBCXX_DEBUG_ASSERT(m_over_top < max_entries); + m_a_entries[m_over_top++] = p_nd; + PB_DS_ASSERT_VALID((*this)) + } + + template<typename _Node, typename _Alloc> + inline void + rc<_Node, _Alloc>:: + pop() + { + PB_DS_ASSERT_VALID((*this)) + _GLIBCXX_DEBUG_ASSERT(!empty()); + --m_over_top; + PB_DS_ASSERT_VALID((*this)) + } + + template<typename _Node, typename _Alloc> + inline typename rc<_Node, _Alloc>::node_pointer + rc<_Node, _Alloc>:: + top() const + { + PB_DS_ASSERT_VALID((*this)) + _GLIBCXX_DEBUG_ASSERT(!empty()); + return *(m_a_entries + m_over_top - 1); + } + + template<typename _Node, typename _Alloc> + inline bool + rc<_Node, _Alloc>:: + empty() const + { + PB_DS_ASSERT_VALID((*this)) + return m_over_top == 0; + } + + template<typename _Node, typename _Alloc> + inline typename rc<_Node, _Alloc>::size_type + rc<_Node, _Alloc>:: + size() const + { return m_over_top; } + + template<typename _Node, typename _Alloc> + void + rc<_Node, _Alloc>:: + clear() + { + PB_DS_ASSERT_VALID((*this)) + m_over_top = 0; + PB_DS_ASSERT_VALID((*this)) + } + + template<typename _Node, typename _Alloc> + const typename rc<_Node, _Alloc>::const_iterator + rc<_Node, _Alloc>:: + begin() const + { return& m_a_entries[0]; } + + template<typename _Node, typename _Alloc> + const typename rc<_Node, _Alloc>::const_iterator + rc<_Node, _Alloc>:: + end() const + { return& m_a_entries[m_over_top]; } + +#ifdef _GLIBCXX_DEBUG + template<typename _Node, typename _Alloc> + void + rc<_Node, _Alloc>:: + assert_valid(const char* __file, int __line) const + { PB_DS_DEBUG_VERIFY(m_over_top < max_entries); } +#endif + +#ifdef PB_DS_RC_BINOMIAL_HEAP_TRACE_ + template<typename _Node, typename _Alloc> + void + rc<_Node, _Alloc>:: + trace() const + { + std::cout << "rc" << std::endl; + for (size_type i = 0; i < m_over_top; ++i) + std::cerr << m_a_entries[i] << std::endl; + std::cout << std::endl; + } +#endif +} // namespace detail +} // namespace __gnu_pbds + +#endif diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/rc_binomial_heap_.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/rc_binomial_heap_.hpp new file mode 100644 index 0000000..189e92e --- /dev/null +++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/rc_binomial_heap_.hpp @@ -0,0 +1,171 @@ +// -*- C++ -*- + +// Copyright (C) 2005-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License as published by the Free Software +// Foundation; either version 3, or (at your option) any later +// version. + +// This library is distributed in the hope that it will be useful, but +// WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL. + +// Permission to use, copy, modify, sell, and distribute this software +// is hereby granted without fee, provided that the above copyright +// notice appears in all copies, and that both that copyright notice +// and this permission notice appear in supporting documentation. None +// of the above authors, nor IBM Haifa Research Laboratories, make any +// representation about the suitability of this software for any +// purpose. It is provided "as is" without express or implied +// warranty. + +/** + * @file rc_binomial_heap_/rc_binomial_heap_.hpp + * Contains an implementation for redundant-counter binomial heap. + */ + +#include <ext/pb_ds/detail/cond_dealtor.hpp> +#include <ext/pb_ds/detail/type_utils.hpp> +#include <ext/pb_ds/detail/binomial_heap_base_/binomial_heap_base_.hpp> +#include <ext/pb_ds/detail/rc_binomial_heap_/rc.hpp> +#include <debug/debug.h> + +namespace __gnu_pbds +{ + namespace detail + { +#define PB_DS_CLASS_T_DEC \ + template<typename Value_Type, typename Cmp_Fn, typename _Alloc> + +#define PB_DS_CLASS_C_DEC \ + rc_binomial_heap<Value_Type, Cmp_Fn, _Alloc> + +#define PB_DS_RC_C_DEC \ + rc<typename binomial_heap_base<Value_Type, Cmp_Fn, _Alloc>::node, _Alloc> + + /** + * Redundant-counter binomial heap. + * + * @ingroup heap-detail + */ + template<typename Value_Type, typename Cmp_Fn, typename _Alloc> + class rc_binomial_heap + : public binomial_heap_base<Value_Type, Cmp_Fn, _Alloc> + { + private: + typedef binomial_heap_base<Value_Type, Cmp_Fn, _Alloc> + base_type; + typedef typename base_type::node_pointer node_pointer; + typedef typename base_type::node_const_pointer node_const_pointer; + typedef PB_DS_RC_C_DEC rc_t; + + public: + typedef Value_Type value_type; + typedef typename _Alloc::size_type size_type; + typedef typename _Alloc::difference_type difference_type; + typedef typename base_type::pointer pointer; + typedef typename base_type::const_pointer const_pointer; + typedef typename base_type::reference reference; + typedef typename base_type::const_reference const_reference; + typedef typename base_type::point_const_iterator point_const_iterator; + typedef typename base_type::point_iterator point_iterator; + typedef typename base_type::const_iterator const_iterator; + typedef typename base_type::iterator iterator; + typedef typename base_type::cmp_fn cmp_fn; + typedef typename base_type::allocator_type allocator_type; + + rc_binomial_heap(); + + rc_binomial_heap(const Cmp_Fn&); + + rc_binomial_heap(const PB_DS_CLASS_C_DEC&); + + ~rc_binomial_heap(); + + void + swap(PB_DS_CLASS_C_DEC&); + + inline point_iterator + push(const_reference); + + void + modify(point_iterator, const_reference); + + inline void + pop(); + + void + erase(point_iterator); + + inline void + clear(); + + template<typename Pred> + size_type + erase_if(Pred); + + template<typename Pred> + void + split(Pred, PB_DS_CLASS_C_DEC&); + + void + join(PB_DS_CLASS_C_DEC&); + +#ifdef _GLIBCXX_DEBUG + void + assert_valid(const char*, int) const; +#endif + +#ifdef PB_DS_RC_BINOMIAL_HEAP_TRACE_ + void + trace() const; +#endif + + private: + + inline node_pointer + link_with_next_sibling(node_pointer); + + void + make_0_exposed(); + + void + make_binomial_heap(); + +#ifdef _GLIBCXX_DEBUG + static node_const_pointer + next_2_pointer(node_const_pointer); + + static node_const_pointer + next_after_0_pointer(node_const_pointer); +#endif + + rc_t m_rc; + }; + +#include <ext/pb_ds/detail/rc_binomial_heap_/constructors_destructor_fn_imps.hpp> +#include <ext/pb_ds/detail/rc_binomial_heap_/debug_fn_imps.hpp> +#include <ext/pb_ds/detail/rc_binomial_heap_/erase_fn_imps.hpp> +#include <ext/pb_ds/detail/rc_binomial_heap_/trace_fn_imps.hpp> +#include <ext/pb_ds/detail/rc_binomial_heap_/insert_fn_imps.hpp> +#include <ext/pb_ds/detail/rc_binomial_heap_/split_join_fn_imps.hpp> + +#undef PB_DS_CLASS_C_DEC +#undef PB_DS_CLASS_T_DEC +#undef PB_DS_RC_C_DEC + } // namespace detail +} // namespace __gnu_pbds diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/split_join_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/split_join_fn_imps.hpp new file mode 100644 index 0000000..9497226 --- /dev/null +++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/split_join_fn_imps.hpp @@ -0,0 +1,77 @@ +// -*- C++ -*- + +// Copyright (C) 2005-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License as published by the Free Software +// Foundation; either version 3, or (at your option) any later +// version. + +// This library is distributed in the hope that it will be useful, but +// WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL. + +// Permission to use, copy, modify, sell, and distribute this software +// is hereby granted without fee, provided that the above copyright +// notice appears in all copies, and that both that copyright notice +// and this permission notice appear in supporting documentation. None +// of the above authors, nor IBM Haifa Research Laboratories, make any +// representation about the suitability of this software for any +// purpose. It is provided "as is" without express or implied +// warranty. + +/** + * @file rc_binomial_heap_/split_join_fn_imps.hpp + * Contains an implementation for rc_binomial_heap_. + */ + +PB_DS_CLASS_T_DEC +template<typename Pred> +void +PB_DS_CLASS_C_DEC:: +split(Pred pred, PB_DS_CLASS_C_DEC& other) +{ + PB_DS_ASSERT_VALID((*this)) + PB_DS_ASSERT_VALID(other) + + make_binomial_heap(); + other.make_binomial_heap(); + base_type::split(pred, other); + base_type::find_max(); + other.find_max(); + + PB_DS_ASSERT_VALID((*this)) + PB_DS_ASSERT_VALID(other) +} + +PB_DS_CLASS_T_DEC +inline void +PB_DS_CLASS_C_DEC:: +join(PB_DS_CLASS_C_DEC& other) +{ + PB_DS_ASSERT_VALID((*this)) + PB_DS_ASSERT_VALID(other) + + make_binomial_heap(); + other.make_binomial_heap(); + base_type::join(other); + base_type::find_max(); + other.find_max(); + + PB_DS_ASSERT_VALID((*this)) + PB_DS_ASSERT_VALID(other) +} + diff --git a/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/trace_fn_imps.hpp b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/trace_fn_imps.hpp new file mode 100644 index 0000000..e4dfd3a --- /dev/null +++ b/gcc-4.9/libstdc++-v3/include/ext/pb_ds/detail/rc_binomial_heap_/trace_fn_imps.hpp @@ -0,0 +1,52 @@ +// -*- C++ -*- + +// Copyright (C) 2005-2014 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the terms +// of the GNU General Public License as published by the Free Software +// Foundation; either version 3, or (at your option) any later +// version. + +// This library is distributed in the hope that it will be useful, but +// WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// General Public License for more details. + +// Under Section 7 of GPL version 3, you are granted additional +// permissions described in the GCC Runtime Library Exception, version +// 3.1, as published by the Free Software Foundation. + +// You should have received a copy of the GNU General Public License and +// a copy of the GCC Runtime Library Exception along with this program; +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see +// <http://www.gnu.org/licenses/>. + +// Copyright (C) 2004 Ami Tavory and Vladimir Dreizin, IBM-HRL. + +// Permission to use, copy, modify, sell, and distribute this software +// is hereby granted without fee, provided that the above copyright +// notice appears in all copies, and that both that copyright notice +// and this permission notice appear in supporting documentation. None +// of the above authors, nor IBM Haifa Research Laboratories, make any +// representation about the suitability of this software for any +// purpose. It is provided "as is" without express or implied +// warranty. + +/** + * @file rc_binomial_heap_/trace_fn_imps.hpp + * Contains an implementation for rc_binomial_heap_. + */ + +#ifdef PB_DS_RC_BINOMIAL_HEAP_TRACE_ + +PB_DS_CLASS_T_DEC +void +PB_DS_CLASS_C_DEC:: +trace() const +{ + base_type::trace(); + m_rc.trace(); +} + +#endif // #ifdef PB_DS_RC_BINOMIAL_HEAP_TRACE_ |