passenger 6.0.19 → 6.0.21

data/src/cxx_supportlib/vendor-modified/boost/intrusive/circular_slist_algorithms.hpp

@@ -146,7 +146,7 @@ class circular_slist_algorithms
    //! <b>Complexity</b>: Constant
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static void init_header(node_ptr this_node) BOOST_NOEXCEPT
+   inline static void init_header(node_ptr this_node) BOOST_NOEXCEPT
    {  NodeTraits::set_next(this_node, this_node);  }
 
    //! <b>Requires</b>: 'p' is the first node of a list.
@@ -156,7 +156,7 @@ class circular_slist_algorithms
    //! <b>Complexity</b>: Constant time.
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr end_node(const_node_ptr p) BOOST_NOEXCEPT
+   inline static node_ptr end_node(const_node_ptr p) BOOST_NOEXCEPT
    {  return detail::uncast(p);   }
 
    //! <b>Effects</b>: Returns true if this_node_points to an empty list.
@@ -164,7 +164,7 @@ class circular_slist_algorithms
    //! <b>Complexity</b>: Constant
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static bool is_empty(const_node_ptr this_node) BOOST_NOEXCEPT
+   inline static bool is_empty(const_node_ptr this_node) BOOST_NOEXCEPT
    {  return NodeTraits::get_next(this_node) == this_node;  }
 
    //! <b>Effects</b>: Returns true if this_node points to a sentinel node.
@@ -172,7 +172,7 @@ class circular_slist_algorithms
    //! <b>Complexity</b>: Constant
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static bool is_sentinel(const_node_ptr this_node) BOOST_NOEXCEPT
+   inline static bool is_sentinel(const_node_ptr this_node) BOOST_NOEXCEPT
    {  return NodeTraits::get_next(this_node) == node_ptr();  }
 
    //! <b>Effects</b>: Marks this node as a "sentinel" node, a special state that is different from "empty",
@@ -181,7 +181,7 @@ class circular_slist_algorithms
    //! <b>Complexity</b>: Constant
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static void set_sentinel(node_ptr this_node) BOOST_NOEXCEPT
+   inline static void set_sentinel(node_ptr this_node) BOOST_NOEXCEPT
    {  NodeTraits::set_next(this_node, node_ptr());   }
 
    //! <b>Requires</b>: this_node and prev_init_node must be in the same circular list.
@@ -193,7 +193,7 @@ class circular_slist_algorithms
    //! <b>Complexity</b>: Linear to the number of elements between prev_init_node and this_node.
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_previous_node(node_ptr prev_init_node, node_ptr this_node) BOOST_NOEXCEPT
+   inline static node_ptr get_previous_node(node_ptr prev_init_node, node_ptr this_node) BOOST_NOEXCEPT
    {  return base_t::get_previous_node(prev_init_node, this_node);   }
 
    //! <b>Requires</b>: this_node must be in a circular list or be an empty circular list.
@@ -203,7 +203,7 @@ class circular_slist_algorithms
    //! <b>Complexity</b>: Linear to the number of elements in the circular list.
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_previous_node(node_ptr this_node) BOOST_NOEXCEPT
+   inline static node_ptr get_previous_node(node_ptr this_node) BOOST_NOEXCEPT
    {  return base_t::get_previous_node(this_node, this_node); }
 
    //! <b>Requires</b>: this_node must be in a circular list or be an empty circular list.
@@ -213,7 +213,7 @@ class circular_slist_algorithms
    //! <b>Complexity</b>: Linear to the number of elements in the circular list.
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_previous_previous_node(node_ptr this_node) BOOST_NOEXCEPT
+   inline static node_ptr get_previous_previous_node(node_ptr this_node) BOOST_NOEXCEPT
    {  return get_previous_previous_node(this_node, this_node); }
 
    //! <b>Requires</b>: this_node and p must be in the same circular list.
@@ -276,7 +276,7 @@ class circular_slist_algorithms
    //! <b>Complexity</b>: Linear to the number of elements in the circular list.
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static void link_before (node_ptr nxt_node, node_ptr this_node) BOOST_NOEXCEPT
+   inline static void link_before (node_ptr nxt_node, node_ptr this_node) BOOST_NOEXCEPT
    {  base_t::link_after(get_previous_node(nxt_node), this_node);   }
 
    //! <b>Requires</b>: this_node and other_node must be nodes inserted
@@ -453,7 +453,7 @@ class circular_slist_algorithms
    //!
    //! <b>Throws</b>: Nothing.
    template<class Disposer>
-   BOOST_INTRUSIVE_FORCEINLINE static std::size_t detach_and_dispose(node_ptr p, Disposer disposer) BOOST_NOEXCEPT
+   inline static std::size_t detach_and_dispose(node_ptr p, Disposer disposer) BOOST_NOEXCEPT
    {  return base_t::unlink_after_and_dispose(p, p, disposer);   }
 };
 

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/any_node_and_algorithms.hpp

@@ -252,7 +252,7 @@ class any_algorithms
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Nodes</b>: If node is inserted in a tree, this function corrupts the tree.
-   BOOST_INTRUSIVE_FORCEINLINE static void init(node_ptr n) BOOST_NOEXCEPT
+   inline static void init(node_ptr n) BOOST_NOEXCEPT
    {  n->node_ptr_1 = node_ptr();   };
 
    //! <b>Effects</b>: Returns true if 'n' is in the same state as if called init(node)
@@ -260,10 +260,10 @@ class any_algorithms
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static bool inited(const_node_ptr n)
+   inline static bool inited(const_node_ptr n)
    {  return !n->node_ptr_1;  };
 
-   BOOST_INTRUSIVE_FORCEINLINE static bool unique(const_node_ptr n) BOOST_NOEXCEPT
+   inline static bool unique(const_node_ptr n) BOOST_NOEXCEPT
    {  return !n->node_ptr_1; }
 
    static void unlink(node_ptr)

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/array_initializer.hpp

@@ -22,7 +22,7 @@
 #endif
 
 #include <boost/config.hpp>
-#include <boost/core/no_exceptions_support.hpp>
+#include <boost/intrusive/detail/workaround.hpp>
 #include <boost/move/detail/placement_new.hpp>
 #include <boost/move/detail/force_ptr.hpp>
 
@@ -55,20 +55,20 @@ class array_initializer
    {
       char *init_buf = (char*)rawbuf;
       std::size_t i = 0;
-      BOOST_TRY{
+      BOOST_INTRUSIVE_TRY{
          for(; i != N; ++i){
             ::new(init_buf, boost_move_new_t()) T(init);
             init_buf += sizeof(T);
          }
       }
-      BOOST_CATCH(...){
+      BOOST_INTRUSIVE_CATCH(...){
          while(i--){
             init_buf -= sizeof(T);
             move_detail::force_ptr<T*>(init_buf)->~T();
          }
-         BOOST_RETHROW;
+         BOOST_INTRUSIVE_RETHROW;
       }
-      BOOST_CATCH_END
+      BOOST_INTRUSIVE_CATCH_END
    }
 
    operator T* ()

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/common_slist_algorithms.hpp

@@ -22,9 +22,9 @@
 #endif
 
 #include <boost/intrusive/intrusive_fwd.hpp>
+#include <boost/intrusive/detail/workaround.hpp>
 #include <boost/intrusive/detail/assert.hpp>
 #include <boost/intrusive/detail/algo_type.hpp>
-#include <boost/core/no_exceptions_support.hpp>
 #include <cstddef>
 
 namespace boost {
@@ -52,7 +52,7 @@ class common_slist_algorithms
       return p;
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE static void init(node_ptr this_node) BOOST_NOEXCEPT
+   inline static void init(node_ptr this_node) BOOST_NOEXCEPT
    {  NodeTraits::set_next(this_node, node_ptr());  }
 
    static bool unique(const_node_ptr this_node) BOOST_NOEXCEPT
@@ -61,16 +61,16 @@ class common_slist_algorithms
       return !next || next == this_node;
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE static bool inited(const_node_ptr this_node) BOOST_NOEXCEPT
+   inline static bool inited(const_node_ptr this_node) BOOST_NOEXCEPT
    {  return !NodeTraits::get_next(this_node); }
 
-   BOOST_INTRUSIVE_FORCEINLINE static void unlink_after(node_ptr prev_node) BOOST_NOEXCEPT
+   inline static void unlink_after(node_ptr prev_node) BOOST_NOEXCEPT
    {
       const_node_ptr this_node(NodeTraits::get_next(prev_node));
       NodeTraits::set_next(prev_node, NodeTraits::get_next(this_node));
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE static void unlink_after(node_ptr prev_node, node_ptr last_node) BOOST_NOEXCEPT
+   inline static void unlink_after(node_ptr prev_node, node_ptr last_node) BOOST_NOEXCEPT
    {  NodeTraits::set_next(prev_node, last_node);  }
 
    static void link_after(node_ptr prev_node, node_ptr this_node) BOOST_NOEXCEPT
@@ -126,7 +126,7 @@ class common_slist_algorithms
             new_f = cur;
             bcur = cur;
             cur  = node_traits::get_next(cur);
-            BOOST_TRY{
+            BOOST_INTRUSIVE_TRY{
                //Main loop
                while(cur != end){
                   if(pred(cur)){ //Might throw
@@ -145,11 +145,11 @@ class common_slist_algorithms
                   }
                }
             }
-            BOOST_CATCH(...){
+            BOOST_INTRUSIVE_CATCH(...){
                node_traits::set_next(last_to_remove, new_f);
-               BOOST_RETHROW;
+               BOOST_INTRUSIVE_RETHROW;
             }
-            BOOST_CATCH_END
+            BOOST_INTRUSIVE_CATCH_END
             node_traits::set_next(last_to_remove, new_f);
             break;
          }
@@ -216,7 +216,7 @@ class common_slist_algorithms
    //!
    //! <b>Throws</b>: Nothing.
    template<class Disposer>
-   BOOST_INTRUSIVE_FORCEINLINE static void unlink_after_and_dispose(node_ptr bb, Disposer disposer) BOOST_NOEXCEPT
+   inline static void unlink_after_and_dispose(node_ptr bb, Disposer disposer) BOOST_NOEXCEPT
    {
       node_ptr i = node_traits::get_next(bb);
       node_traits::set_next(bb, node_traits::get_next(i));

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/default_header_holder.hpp

@@ -40,14 +40,14 @@ struct default_header_holder : public NodeTraits::node
 
    default_header_holder() : node() {}
 
-   BOOST_INTRUSIVE_FORCEINLINE const_node_ptr get_node() const
+   inline const_node_ptr get_node() const
    { return pointer_traits< const_node_ptr >::pointer_to(*static_cast< const node* >(this)); }
 
-   BOOST_INTRUSIVE_FORCEINLINE node_ptr get_node()
+   inline node_ptr get_node()
    { return pointer_traits< node_ptr >::pointer_to(*static_cast< node* >(this)); }
 
    // (unsafe) downcast used to implement container-from-iterator
-   BOOST_INTRUSIVE_FORCEINLINE static default_header_holder* get_holder(node_ptr p)
+   inline static default_header_holder* get_holder(node_ptr p)
    { return static_cast< default_header_holder* >(boost::movelib::to_raw_pointer(p)); }
 };
 

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/ebo_functor_holder.hpp

@@ -166,57 +166,57 @@ class ebo_functor_holder
    public:
    typedef T functor_type;
 
-   BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder()
+   inline ebo_functor_holder()
       : t_()
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE explicit ebo_functor_holder(const T &t)
+   inline explicit ebo_functor_holder(const T &t)
       : t_(t)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE explicit ebo_functor_holder(BOOST_RV_REF(T) t)
+   inline explicit ebo_functor_holder(BOOST_RV_REF(T) t)
       : t_(::boost::move(t))
    {}
 
    template<class Arg1, class Arg2>
-   BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder(BOOST_FWD_REF(Arg1) arg1, BOOST_FWD_REF(Arg2) arg2)
+   inline ebo_functor_holder(BOOST_FWD_REF(Arg1) arg1, BOOST_FWD_REF(Arg2) arg2)
       : t_(::boost::forward<Arg1>(arg1), ::boost::forward<Arg2>(arg2))
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder(const ebo_functor_holder &x)
+   inline ebo_functor_holder(const ebo_functor_holder &x)
       : t_(x.t_)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder(BOOST_RV_REF(ebo_functor_holder) x)
+   inline ebo_functor_holder(BOOST_RV_REF(ebo_functor_holder) x)
       : t_(x.t_)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder& operator=(BOOST_COPY_ASSIGN_REF(ebo_functor_holder) x)
+   inline ebo_functor_holder& operator=(BOOST_COPY_ASSIGN_REF(ebo_functor_holder) x)
    {
       this->get() = x.get();
       return *this;
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder& operator=(BOOST_RV_REF(ebo_functor_holder) x)
+   inline ebo_functor_holder& operator=(BOOST_RV_REF(ebo_functor_holder) x)
    {
       this->get() = ::boost::move(x.get());
       return *this;
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder& operator=(const T &x)
+   inline ebo_functor_holder& operator=(const T &x)
    {
       this->get() = x;
       return *this;
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder& operator=(BOOST_RV_REF(T) x)
+   inline ebo_functor_holder& operator=(BOOST_RV_REF(T) x)
    {
       this->get() = ::boost::move(x);
       return *this;
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE T&       get(){return t_;}
-   BOOST_INTRUSIVE_FORCEINLINE const T& get()const{return t_;}
+   inline T&       get(){return t_;}
+   inline const T& get()const{return t_;}
 
    private:
    T t_;
@@ -231,58 +231,58 @@ class ebo_functor_holder<T, Tag, false>
    public:
    typedef T functor_type;
 
-   BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder()
+   inline ebo_functor_holder()
       : T()
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE explicit ebo_functor_holder(const T &t)
+   inline explicit ebo_functor_holder(const T &t)
       : T(t)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE explicit ebo_functor_holder(BOOST_RV_REF(T) t)
+   inline explicit ebo_functor_holder(BOOST_RV_REF(T) t)
       : T(::boost::move(t))
    {}
 
    template<class Arg1, class Arg2>
-   BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder(BOOST_FWD_REF(Arg1) arg1, BOOST_FWD_REF(Arg2) arg2)
+   inline ebo_functor_holder(BOOST_FWD_REF(Arg1) arg1, BOOST_FWD_REF(Arg2) arg2)
       : T(::boost::forward<Arg1>(arg1), ::boost::forward<Arg2>(arg2))
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder(const ebo_functor_holder &x)
+   inline ebo_functor_holder(const ebo_functor_holder &x)
       : T(static_cast<const T&>(x))
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder(BOOST_RV_REF(ebo_functor_holder) x)
+   inline ebo_functor_holder(BOOST_RV_REF(ebo_functor_holder) x)
       : T(BOOST_MOVE_BASE(T, x))
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder& operator=(BOOST_COPY_ASSIGN_REF(ebo_functor_holder) x)
+   inline ebo_functor_holder& operator=(BOOST_COPY_ASSIGN_REF(ebo_functor_holder) x)
    {
       const ebo_functor_holder&r = x;
       this->get() = r;
       return *this;
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder& operator=(BOOST_RV_REF(ebo_functor_holder) x)
+   inline ebo_functor_holder& operator=(BOOST_RV_REF(ebo_functor_holder) x)
    {
       this->get() = ::boost::move(x.get());
       return *this;
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder& operator=(const T &x)
+   inline ebo_functor_holder& operator=(const T &x)
    {
       this->get() = x;
       return *this;
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE ebo_functor_holder& operator=(BOOST_RV_REF(T) x)
+   inline ebo_functor_holder& operator=(BOOST_RV_REF(T) x)
    {
       this->get() = ::boost::move(x);
       return *this;
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE T&       get(){return *this;}
-   BOOST_INTRUSIVE_FORCEINLINE const T& get()const{return *this;}
+   inline T&       get(){return *this;}
+   inline const T& get()const{return *this;}
 };
 
 }  //namespace detail {

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/equal_to_value.hpp

@@ -39,7 +39,7 @@ class equal_to_value
       :  t_(t)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE bool operator()(ConstReference t)const
+   inline bool operator()(ConstReference t)const
    {  return t_ == t;   }
 };
 

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/exception_disposer.hpp

@@ -41,7 +41,7 @@ class exception_disposer
       :  cont_(&cont), disp_(disp)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE void release()
+   inline void release()
    {  cont_ = 0;  }
 
    ~exception_disposer()

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/generic_hook.hpp

@@ -27,7 +27,6 @@
 #include <boost/intrusive/detail/assert.hpp>
 #include <boost/intrusive/detail/node_holder.hpp>
 #include <boost/intrusive/detail/algo_type.hpp>
-#include <boost/static_assert.hpp>
 
 namespace boost {
 namespace intrusive {
@@ -41,7 +40,7 @@ struct link_dispatch
 {};
 
 template<class Hook>
-BOOST_INTRUSIVE_FORCEINLINE void destructor_impl(Hook &hook, detail::link_dispatch<safe_link>)
+inline void destructor_impl(Hook &hook, detail::link_dispatch<safe_link>)
 {  //If this assertion raises, you might have destroyed an object
    //while it was still inserted in a container that is alive.
    //If so, remove the object from the container before destroying it.
@@ -49,11 +48,11 @@ BOOST_INTRUSIVE_FORCEINLINE void destructor_impl(Hook &hook, detail::link_dispat
 }
 
 template<class Hook>
-BOOST_INTRUSIVE_FORCEINLINE void destructor_impl(Hook &hook, detail::link_dispatch<auto_unlink>)
+inline void destructor_impl(Hook &hook, detail::link_dispatch<auto_unlink>)
 {  hook.unlink();  }
 
 template<class Hook>
-BOOST_INTRUSIVE_FORCEINLINE void destructor_impl(Hook &, detail::link_dispatch<normal_link>)
+inline void destructor_impl(Hook &, detail::link_dispatch<normal_link>)
 {}
 
 }  //namespace detail {
@@ -161,54 +160,54 @@ class generic_hook
       < NodeTraits
       , Tag, LinkMode, BaseHookType>                  hooktags;
 
-   BOOST_INTRUSIVE_FORCEINLINE node_ptr this_ptr() BOOST_NOEXCEPT
+   inline node_ptr this_ptr() BOOST_NOEXCEPT
    {  return pointer_traits<node_ptr>::pointer_to(static_cast<node&>(*this)); }
 
-   BOOST_INTRUSIVE_FORCEINLINE const_node_ptr this_ptr() const BOOST_NOEXCEPT
+   inline const_node_ptr this_ptr() const BOOST_NOEXCEPT
    {  return pointer_traits<const_node_ptr>::pointer_to(static_cast<const node&>(*this)); }
 
    public:
    /// @endcond
 
-   BOOST_INTRUSIVE_FORCEINLINE generic_hook() BOOST_NOEXCEPT
+   inline generic_hook() BOOST_NOEXCEPT
    {
       if(hooktags::safemode_or_autounlink){
          node_algorithms::init(this->this_ptr());
       }
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE generic_hook(const generic_hook& ) BOOST_NOEXCEPT
+   inline generic_hook(const generic_hook& ) BOOST_NOEXCEPT
    {
       if(hooktags::safemode_or_autounlink){
          node_algorithms::init(this->this_ptr());
       }
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE generic_hook& operator=(const generic_hook& ) BOOST_NOEXCEPT
+   inline generic_hook& operator=(const generic_hook& ) BOOST_NOEXCEPT
    {  return *this;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE ~generic_hook()
+   inline ~generic_hook()
    {
       destructor_impl
          (*this, detail::link_dispatch<hooktags::link_mode>());
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE void swap_nodes(generic_hook &other) BOOST_NOEXCEPT
+   inline void swap_nodes(generic_hook &other) BOOST_NOEXCEPT
    {
       node_algorithms::swap_nodes
          (this->this_ptr(), other.this_ptr());
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE bool is_linked() const BOOST_NOEXCEPT
+   inline bool is_linked() const BOOST_NOEXCEPT
    {
       //is_linked() can be only used in safe-mode or auto-unlink
-      BOOST_STATIC_ASSERT(( hooktags::safemode_or_autounlink ));
+      BOOST_INTRUSIVE_STATIC_ASSERT(( hooktags::safemode_or_autounlink ));
       return !node_algorithms::unique(this->this_ptr());
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE void unlink() BOOST_NOEXCEPT
+   inline void unlink() BOOST_NOEXCEPT
    {
-      BOOST_STATIC_ASSERT(( (int)hooktags::link_mode == (int)auto_unlink ));
+      BOOST_INTRUSIVE_STATIC_ASSERT(( (int)hooktags::link_mode == (int)auto_unlink ));
       node_ptr n(this->this_ptr());
       if(!node_algorithms::inited(n)){
          node_algorithms::unlink(n);