File Manager

Hackfut Security File Manager

Current Path: /opt/passenger-5.3.7-4.el6.cloudlinux/src/cxx_supportlib/vendor-modified/boost/intrusive/detail

opt / passenger-5.3.7-4.el6.cloudlinux / src / cxx_supportlib / vendor-modified / boost / intrusive / detail /

📁 ..
📄 algo_type.hpp(1.27 KB)
📄 algorithm.hpp(2.81 KB)
📄 any_node_and_algorithms.hpp(9.46 KB)
📄 array_initializer.hpp(2.18 KB)
📄 assert.hpp(1.48 KB)
📄 avltree_node.hpp(6.64 KB)
📄 bstree_algorithms_base.hpp(5.39 KB)
📄 common_slist_algorithms.hpp(5.93 KB)
📄 config_begin.hpp(2.4 KB)
📄 config_end.hpp(496 B)
📄 default_header_holder.hpp(2.19 KB)
📄 ebo_functor_holder.hpp(7.78 KB)
📄 empty_node_checker.hpp(1.21 KB)
📄 equal_to_value.hpp(1.19 KB)
📄 exception_disposer.hpp(2.08 KB)
📄 function_detector.hpp(3.38 KB)
📄 generic_hook.hpp(6.11 KB)
📄 get_value_traits.hpp(6.93 KB)
📄 has_member_function_callable_with.hpp(18.01 KB)
📄 hashtable_node.hpp(9.46 KB)
📄 hook_traits.hpp(8.05 KB)
📄 iiterator.hpp(4.34 KB)
📄 is_stateful_value_traits.hpp(2.46 KB)
📄 iterator.hpp(7.41 KB)
📄 key_nodeptr_comp.hpp(4.74 KB)
📄 list_iterator.hpp(4.65 KB)
📄 list_node.hpp(2.13 KB)
📄 math.hpp(7.86 KB)
📄 minimal_less_equal_header.hpp(932 B)
📄 minimal_pair_header.hpp(904 B)
📄 mpl.hpp(8.36 KB)
📄 node_cloner_disposer.hpp(3.83 KB)
📄 node_holder.hpp(883 B)
📄 node_to_value.hpp(3.9 KB)
📄 parent_from_member.hpp(4.09 KB)
📄 rbtree_node.hpp(6.88 KB)
📄 reverse_iterator.hpp(4.54 KB)
📄 simple_disposers.hpp(1.12 KB)
📄 size_holder.hpp(2.21 KB)
📄 slist_iterator.hpp(4.39 KB)
📄 slist_node.hpp(1.88 KB)
📄 std_fwd.hpp(1.2 KB)
📄 transform_iterator.hpp(5.65 KB)
📄 tree_iterator.hpp(6.11 KB)
📄 tree_node.hpp(2.3 KB)
📄 tree_value_compare.hpp(6.69 KB)
📄 uncast.hpp(1.61 KB)
📄 workaround.hpp(1.81 KB)

Editing: hook_traits.hpp

/////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gaztanaga  2006-2014
//
// Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE_1_0.txt or copy at
//          http://www.boost.org/LICENSE_1_0.txt)
//
// See http://www.boost.org/libs/intrusive for documentation.
//
/////////////////////////////////////////////////////////////////////////////

#ifndef BOOST_INTRUSIVE_DETAIL_HOOK_TRAITS_HPP
#define BOOST_INTRUSIVE_DETAIL_HOOK_TRAITS_HPP

#ifndef BOOST_CONFIG_HPP
#  include <boost/config.hpp>
#endif

#if defined(BOOST_HAS_PRAGMA_ONCE)
#  pragma once
#endif

#include <boost/intrusive/detail/workaround.hpp>
#include <boost/intrusive/pointer_traits.hpp>
#include <boost/intrusive/detail/parent_from_member.hpp>
#include <boost/intrusive/link_mode.hpp>
#include <boost/intrusive/detail/mpl.hpp>
#include <boost/move/detail/to_raw_pointer.hpp>
#include <boost/intrusive/detail/node_holder.hpp>

namespace boost {
namespace intrusive {

template<class T, class NodePtr, class Tag, unsigned int Type>
struct bhtraits_base
{
   public:
   typedef NodePtr                                                   node_ptr;
   typedef typename pointer_traits<node_ptr>::element_type           node;
   typedef node_holder<node, Tag, Type>                              node_holder_type;
   typedef T                                                         value_type;
   typedef typename pointer_traits<node_ptr>::
      template rebind_pointer<const node>::type                      const_node_ptr;
   typedef typename pointer_traits<node_ptr>::
      template rebind_pointer<T>::type                               pointer;
   typedef typename pointer_traits<node_ptr>::
      template rebind_pointer<const T>::type                         const_pointer;
   //typedef typename pointer_traits<pointer>::reference               reference;
   //typedef typename pointer_traits<const_pointer>::reference         const_reference;
   typedef T &                                                       reference;
   typedef const T &                                                 const_reference;
   typedef node_holder_type &                                        node_holder_reference;
   typedef const node_holder_type &                                  const_node_holder_reference;
   typedef node&                                                     node_reference;
   typedef const node &                                              const_node_reference;

BOOST_INTRUSIVE_FORCEINLINE static pointer to_value_ptr(const node_ptr & n)
   {
      return pointer_traits<pointer>::pointer_to
         (static_cast<reference>(static_cast<node_holder_reference>(*n)));
   }

BOOST_INTRUSIVE_FORCEINLINE static const_pointer to_value_ptr(const const_node_ptr & n)
   {
      return pointer_traits<const_pointer>::pointer_to
         (static_cast<const_reference>(static_cast<const_node_holder_reference>(*n)));
   }

BOOST_INTRUSIVE_FORCEINLINE static node_ptr to_node_ptr(reference value)
   {
      return pointer_traits<node_ptr>::pointer_to
         (static_cast<node_reference>(static_cast<node_holder_reference>(value)));
   }

BOOST_INTRUSIVE_FORCEINLINE static const_node_ptr to_node_ptr(const_reference value)
   {
      return pointer_traits<const_node_ptr>::pointer_to
         (static_cast<const_node_reference>(static_cast<const_node_holder_reference>(value)));
   }
};

template<class T, class NodeTraits, link_mode_type LinkMode, class Tag, unsigned int Type>
struct bhtraits
   : public bhtraits_base<T, typename NodeTraits::node_ptr, Tag, Type>
{
   static const link_mode_type link_mode = LinkMode;
   typedef NodeTraits node_traits;
};

template<class T, class Hook, Hook T::* P>
struct mhtraits
{
   public:
   typedef Hook                                                      hook_type;
   typedef typename hook_type::hooktags::node_traits                 node_traits;
   typedef typename node_traits::node                                node;
   typedef T                                                         value_type;
   typedef typename node_traits::node_ptr                            node_ptr;
   typedef typename node_traits::const_node_ptr                      const_node_ptr;
   typedef typename pointer_traits<node_ptr>::
      template rebind_pointer<T>::type                               pointer;
   typedef typename pointer_traits<node_ptr>::
      template rebind_pointer<const T>::type                         const_pointer;
   typedef T &                                                       reference;
   typedef const T &                                                 const_reference;
   typedef node&                                                     node_reference;
   typedef const node &                                              const_node_reference;
   typedef hook_type&                                                hook_reference;
   typedef const hook_type &                                         const_hook_reference;

static const link_mode_type link_mode = Hook::hooktags::link_mode;

BOOST_INTRUSIVE_FORCEINLINE static pointer to_value_ptr(const node_ptr & n)
   {
      return pointer_traits<pointer>::pointer_to
         (*detail::parent_from_member<T, Hook>
            (static_cast<Hook*>(boost::movelib::to_raw_pointer(n)), P));
   }

BOOST_INTRUSIVE_FORCEINLINE static const_pointer to_value_ptr(const const_node_ptr & n)
   {
      return pointer_traits<const_pointer>::pointer_to
         (*detail::parent_from_member<T, Hook>
            (static_cast<const Hook*>(boost::movelib::to_raw_pointer(n)), P));
   }
};

template<class Functor>
struct fhtraits
{
   public:
   typedef typename Functor::hook_type                               hook_type;
   typedef typename Functor::hook_ptr                                hook_ptr;
   typedef typename Functor::const_hook_ptr                          const_hook_ptr;
   typedef typename hook_type::hooktags::node_traits                 node_traits;
   typedef typename node_traits::node                                node;
   typedef typename Functor::value_type                              value_type;
   typedef typename node_traits::node_ptr                            node_ptr;
   typedef typename node_traits::const_node_ptr                      const_node_ptr;
   typedef typename pointer_traits<node_ptr>::
      template rebind_pointer<value_type>::type                      pointer;
   typedef typename pointer_traits<node_ptr>::
      template rebind_pointer<const value_type>::type                const_pointer;
   typedef value_type &                                              reference;
   typedef const value_type &                                        const_reference;
   static const link_mode_type link_mode = hook_type::hooktags::link_mode;

static node_ptr to_node_ptr(reference value)
   {  return static_cast<node*>(boost::movelib::to_raw_pointer(Functor::to_hook_ptr(value)));  }

static const_node_ptr to_node_ptr(const_reference value)
   {  return static_cast<const node*>(boost::movelib::to_raw_pointer(Functor::to_hook_ptr(value)));  }

static pointer to_value_ptr(const node_ptr & n)
   {  return Functor::to_value_ptr(to_hook_ptr(n));  }

static const_pointer to_value_ptr(const const_node_ptr & n)
   {  return Functor::to_value_ptr(to_hook_ptr(n));  }

private:
   static hook_ptr to_hook_ptr(const node_ptr & n)
   {  return hook_ptr(&*static_cast<hook_type*>(&*n));  }

static const_hook_ptr to_hook_ptr(const const_node_ptr & n)
   {  return const_hook_ptr(&*static_cast<const hook_type*>(&*n));  }
};

} //namespace intrusive
} //namespace boost

#endif //BOOST_INTRUSIVE_DETAIL_HOOK_TRAITS_HPP

Hackfut Security File Manager

Editing: hook_traits.hpp

Upload File

Create Folder