EIC code displayed by LXR master/​include/​boost/​ptr_container/​ptr_set_adapter.hpp	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-01-18 09:50:36

 //
 // Boost.Pointer Container
 //
 //  Copyright Thorsten Ottosen 2003-2005. Use, modification and
 //  distribution is subject to 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)
 //
 // For more information, see http://www.boost.org/libs/ptr_container/
 //
 
 #ifndef BOOST_PTR_CONTAINER_PTR_SET_ADAPTER_HPP
 #define BOOST_PTR_CONTAINER_PTR_SET_ADAPTER_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif
 
 #include <boost/ptr_container/detail/associative_ptr_container.hpp>
 #include <boost/ptr_container/detail/meta_functions.hpp>
 #include <boost/ptr_container/detail/void_ptr_iterator.hpp>
 #include <boost/ptr_container/detail/ptr_container_disable_deprecated.hpp>
 #include <boost/range/iterator_range.hpp>
 
 #if defined(BOOST_PTR_CONTAINER_DISABLE_DEPRECATED)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
 #endif
 
 namespace boost
 {
 namespace ptr_container_detail
 {
     template
     <
         class Key,
         class VoidPtrSet,
         bool  Ordered
     >
     struct set_config
     {
        typedef VoidPtrSet
                     void_container_type;
 
        typedef BOOST_DEDUCED_TYPENAME VoidPtrSet::allocator_type
                     allocator_type;
 
        typedef Key  value_type;
 
        typedef value_type
                     key_type;
 
        typedef BOOST_DEDUCED_TYPENAME
            mpl::eval_if_c<Ordered,
                           select_value_compare<VoidPtrSet>,
                           mpl::identity<void> >::type
                     value_compare;
 
        typedef value_compare
                     key_compare;
 
        typedef BOOST_DEDUCED_TYPENAME
            mpl::eval_if_c<Ordered,
                           mpl::identity<void>,
                           select_hasher<VoidPtrSet> >::type
                     hasher;
 
        typedef BOOST_DEDUCED_TYPENAME
            mpl::eval_if_c<Ordered,
                           mpl::identity<void>,
                           select_key_equal<VoidPtrSet> >::type
                     key_equal;
 
        typedef BOOST_DEDUCED_TYPENAME
            mpl::if_c<Ordered,
                      ordered_associative_container_tag,
                      unordered_associative_container_tag>::type
                     container_type;
 
        typedef void_ptr_iterator<
                        BOOST_DEDUCED_TYPENAME VoidPtrSet::iterator, Key >
                     iterator;
 
        typedef void_ptr_iterator<
                         BOOST_DEDUCED_TYPENAME VoidPtrSet::const_iterator, const Key >
                     const_iterator;
 
        typedef void_ptr_iterator<
            BOOST_DEDUCED_TYPENAME
              mpl::eval_if_c<Ordered,
                             select_iterator<VoidPtrSet>,
                             select_local_iterator<VoidPtrSet> >::type,
              Key >
                     local_iterator;
 
        typedef void_ptr_iterator<
            BOOST_DEDUCED_TYPENAME
              mpl::eval_if_c<Ordered,
                             select_iterator<VoidPtrSet>,
                             select_const_local_iterator<VoidPtrSet> >::type,
              const Key >
                     const_local_iterator;
 
        template< class Iter >
        static Key* get_pointer( Iter i )
        {
            return static_cast<Key*>( *i.base() );
        }
 
        template< class Iter >
        static const Key* get_const_pointer( Iter i )
        {
            return static_cast<const Key*>( *i.base() );
        }
 
        BOOST_STATIC_CONSTANT(bool, allow_null = false );
     };
 
 
 
     template
     <
         class Key,
         class VoidPtrSet,
         class CloneAllocator = heap_clone_allocator,
         bool  Ordered        = true
     >
     class ptr_set_adapter_base
         : public ptr_container_detail::associative_ptr_container< set_config<Key,VoidPtrSet,Ordered>,
                                                       CloneAllocator >
     {
         typedef ptr_container_detail::associative_ptr_container< set_config<Key,VoidPtrSet,Ordered>,
                                                      CloneAllocator >
               base_type;
     public:
         typedef BOOST_DEDUCED_TYPENAME base_type::iterator
                       iterator;
         typedef BOOST_DEDUCED_TYPENAME base_type::const_iterator
                       const_iterator;
         typedef Key   key_type;
         typedef BOOST_DEDUCED_TYPENAME base_type::size_type
                       size_type;
 
     public:
         ptr_set_adapter_base()
         { }
 
         template< class SizeType >
         ptr_set_adapter_base( SizeType n,
                               ptr_container_detail::unordered_associative_container_tag tag )
           : base_type( n, tag )
         { }
 
         template< class Compare, class Allocator >
         ptr_set_adapter_base( const Compare& comp,
                               const Allocator& a )
          : base_type( comp, a )
         { }
 
         template< class Hash, class Pred, class Allocator >
         ptr_set_adapter_base( const Hash& hash,
                               const Pred& pred,
                               const Allocator& a )
          : base_type( hash, pred, a )
         { }
 
         template< class InputIterator, class Compare, class Allocator >
         ptr_set_adapter_base( InputIterator first, InputIterator last,
                               const Compare& comp,
                               const Allocator& a )
          : base_type( first, last, comp, a )
         { }
 
         template< class InputIterator, class Hash, class Pred, class Allocator >
         ptr_set_adapter_base( InputIterator first, InputIterator last,
                               const Hash& hash,
                               const Pred& pred,
                               const Allocator& a )
          : base_type( first, last, hash, pred, a )
         { }
 
         template< class U, class Set, class CA, bool b >
         ptr_set_adapter_base( const ptr_set_adapter_base<U,Set,CA,b>& r )
           : base_type( r )
         { }
 
         ptr_set_adapter_base( const ptr_set_adapter_base& r )
           : base_type( r )
         { }
 
 #ifndef BOOST_NO_AUTO_PTR
         template< class PtrContainer >
         explicit ptr_set_adapter_base( std::auto_ptr<PtrContainer> clone )
          : base_type( clone )
         { }
 #endif
 #ifndef BOOST_NO_CXX11_SMART_PTR
         template< class PtrContainer >
         explicit ptr_set_adapter_base( std::unique_ptr<PtrContainer> clone )
          : base_type( std::move( clone ) )
         { }
 #endif
 
         ptr_set_adapter_base& operator=( ptr_set_adapter_base r )
         {
             this->swap( r );
             return *this;
         }
 
 #ifndef BOOST_NO_AUTO_PTR
         template< typename PtrContainer >
         ptr_set_adapter_base& operator=( std::auto_ptr<PtrContainer> clone )
         {
             base_type::operator=( clone );
             return *this;
         }
 #endif
 #ifndef BOOST_NO_CXX11_SMART_PTR
         template< typename PtrContainer >
         ptr_set_adapter_base& operator=( std::unique_ptr<PtrContainer> clone )
         {
             base_type::operator=( std::move( clone ) );
             return *this;
         }
 #endif
 
         using base_type::erase;
 
         size_type erase( const key_type& x ) // nothrow
         {
             key_type* key = const_cast<key_type*>(&x);
             iterator i( this->base().find( key ) );
             if( i == this->end() )                                  // nothrow
                 return 0u;                                          // nothrow
             key = static_cast<key_type*>(*i.base());                // nothrow
             size_type res = this->base().erase( key );              // nothrow
             this->remove( key );                                    // nothrow
             return res;
         }
 
 
         iterator find( const key_type& x )
         {
             return iterator( this->base().
                              find( const_cast<key_type*>(&x) ) );
         }
 
         const_iterator find( const key_type& x ) const
         {
             return const_iterator( this->base().
                                    find( const_cast<key_type*>(&x) ) );
         }
 
         size_type count( const key_type& x ) const
         {
             return this->base().count( const_cast<key_type*>(&x) );
         }
 
         iterator lower_bound( const key_type& x )
         {
             return iterator( this->base().
                              lower_bound( const_cast<key_type*>(&x) ) );
         }
 
         const_iterator lower_bound( const key_type& x ) const
         {
             return const_iterator( this->base().
                                    lower_bound( const_cast<key_type*>(&x) ) );
         }
 
         iterator upper_bound( const key_type& x )
         {
             return iterator( this->base().
                              upper_bound( const_cast<key_type*>(&x) ) );
         }
 
         const_iterator upper_bound( const key_type& x ) const
         {
             return const_iterator( this->base().
                                    upper_bound( const_cast<key_type*>(&x) ) );
         }
 
         iterator_range<iterator> equal_range( const key_type& x )
         {
             std::pair<BOOST_DEDUCED_TYPENAME base_type::ptr_iterator,
                       BOOST_DEDUCED_TYPENAME base_type::ptr_iterator>
                 p = this->base().
                 equal_range( const_cast<key_type*>(&x) );
             return make_iterator_range( iterator( p.first ),
                                         iterator( p.second ) );
         }
 
         iterator_range<const_iterator> equal_range( const key_type& x ) const
         {
             std::pair<BOOST_DEDUCED_TYPENAME base_type::ptr_const_iterator,
                       BOOST_DEDUCED_TYPENAME base_type::ptr_const_iterator>
                 p = this->base().
                 equal_range( const_cast<key_type*>(&x) );
             return make_iterator_range( const_iterator( p.first ),
                                         const_iterator( p.second ) );
         }
 
     protected:
         size_type bucket( const key_type& key ) const
         {
             return this->base().bucket( const_cast<key_type*>(&key) );
         }
     };
 
 } // ptr_container_detail
 
     /////////////////////////////////////////////////////////////////////////
     // ptr_set_adapter
     /////////////////////////////////////////////////////////////////////////
 
     template
     <
         class Key,
         class VoidPtrSet,
         class CloneAllocator = heap_clone_allocator,
         bool  Ordered        = true
     >
     class ptr_set_adapter :
         public ptr_container_detail::ptr_set_adapter_base<Key,VoidPtrSet,CloneAllocator,Ordered>
     {
         typedef ptr_container_detail::ptr_set_adapter_base<Key,VoidPtrSet,CloneAllocator,Ordered>
             base_type;
 
     public: // typedefs
 
         typedef BOOST_DEDUCED_TYPENAME base_type::iterator
                      iterator;
         typedef BOOST_DEDUCED_TYPENAME base_type::const_iterator
                      const_iterator;
         typedef BOOST_DEDUCED_TYPENAME base_type::size_type
                      size_type;
         typedef Key  key_type;
         typedef BOOST_DEDUCED_TYPENAME base_type::auto_type
                      auto_type;
         typedef BOOST_DEDUCED_TYPENAME VoidPtrSet::allocator_type
                      allocator_type;
     private:
 
         template< typename II >
         void set_basic_clone_and_insert( II first, II last ) // basic
         {
             while( first != last )
             {
                 if( this->find( *first ) == this->end() )
                     insert( this->null_policy_allocate_clone_from_iterator( first ) ); // strong, commit
                 ++first;
             }
         }
 
     public:
         ptr_set_adapter()
         { }
 
         template< class SizeType >
         ptr_set_adapter( SizeType n,
                          ptr_container_detail::unordered_associative_container_tag tag )
           : base_type( n, tag )
         { }
 
         template< class Comp >
         explicit ptr_set_adapter( const Comp& comp,
                                   const allocator_type& a )
           : base_type( comp, a )
         {
             BOOST_ASSERT( this->empty() );
         }
 
         template< class SizeType, class Hash, class Pred, class Allocator >
         ptr_set_adapter( SizeType n,
                          const Hash& hash,
                          const Pred& pred,
                          const Allocator& a )
          : base_type( n, hash, pred, a )
         { }
 
         template< class Hash, class Pred, class Allocator >
         ptr_set_adapter( const Hash& hash,
                          const Pred& pred,
                          const Allocator& a )
          : base_type( hash, pred, a )
         { }
 
         template< class InputIterator >
         ptr_set_adapter( InputIterator first, InputIterator last )
          : base_type( first, last )
         { }
 
         template< class InputIterator, class Compare, class Allocator >
         ptr_set_adapter( InputIterator first, InputIterator last,
                          const Compare& comp,
                          const Allocator a = Allocator() )
           : base_type( comp, a )
         {
             BOOST_ASSERT( this->empty() );
             set_basic_clone_and_insert( first, last );
         }
 
         template< class InputIterator, class Hash, class Pred, class Allocator >
         ptr_set_adapter( InputIterator first, InputIterator last,
                          const Hash& hash,
                          const Pred& pred,
                          const Allocator& a )
           : base_type( first, last, hash, pred, a )
         { }
 
         explicit ptr_set_adapter( const ptr_set_adapter& r )
           : base_type( r )
         { }
 
         template< class U, class Set, class CA, bool b >
         explicit ptr_set_adapter( const ptr_set_adapter<U,Set,CA,b>& r )
           : base_type( r )
         { }
 
 #ifndef BOOST_NO_AUTO_PTR
         template< class PtrContainer >
         explicit ptr_set_adapter( std::auto_ptr<PtrContainer> clone )
          : base_type( clone )
         { }
 #endif
 #ifndef BOOST_NO_CXX11_SMART_PTR
         template< class PtrContainer >
         explicit ptr_set_adapter( std::unique_ptr<PtrContainer> clone )
          : base_type( std::move( clone ) )
         { }
 #endif
 
         template< class U, class Set, class CA, bool b >
         ptr_set_adapter& operator=( const ptr_set_adapter<U,Set,CA,b>& r )
         {
             base_type::operator=( r );
             return *this;
         }
 
 #ifndef BOOST_NO_AUTO_PTR
         template< class T >
         void operator=( std::auto_ptr<T> r )
         {
             base_type::operator=( r );
         }
 #endif
 #ifndef BOOST_NO_CXX11_SMART_PTR
         template< class T >
         void operator=( std::unique_ptr<T> r )
         {
             base_type::operator=( std::move( r ) );
         }
 #endif
 
         std::pair<iterator,bool> insert( key_type* x ) // strong
         {
             this->enforce_null_policy( x, "Null pointer in 'ptr_set::insert()'" );
 
             auto_type ptr( x, *this );
             std::pair<BOOST_DEDUCED_TYPENAME base_type::ptr_iterator,bool>
                  res = this->base().insert( x );
             if( res.second )
                 ptr.release();
             return std::make_pair( iterator( res.first ), res.second );
         }
 
 #ifndef BOOST_NO_AUTO_PTR
         template< class U >
         std::pair<iterator,bool> insert( std::auto_ptr<U> x )
         {
             return insert( x.release() );
         }
 #endif
 #ifndef BOOST_NO_CXX11_SMART_PTR
         template< class U >
         std::pair<iterator,bool> insert( std::unique_ptr<U> x )
         {
             return insert( x.release() );
         }
 #endif
 
 
         iterator insert( iterator where, key_type* x ) // strong
         {
             this->enforce_null_policy( x, "Null pointer in 'ptr_set::insert()'" );
 
             auto_type ptr( x, *this );
             BOOST_DEDUCED_TYPENAME base_type::ptr_iterator
                 res = this->base().insert( where.base(), x );
             if( *res == x )
                 ptr.release();
             return iterator( res);
         }
 
 #ifndef BOOST_NO_AUTO_PTR
         template< class U >
         iterator insert( iterator where, std::auto_ptr<U> x )
         {
             return insert( where, x.release() );
         }
 #endif
 #ifndef BOOST_NO_CXX11_SMART_PTR
         template< class U >
         iterator insert( iterator where, std::unique_ptr<U> x )
         {
             return insert( where, x.release() );
         }
 #endif
 
         template< typename InputIterator >
         void insert( InputIterator first, InputIterator last ) // basic
         {
             set_basic_clone_and_insert( first, last );
         }
 
 #if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
 #else
 
         template< class Range >
         BOOST_DEDUCED_TYPENAME
         boost::disable_if< ptr_container_detail::is_pointer_or_integral<Range> >::type
         insert( const Range& r )
         {
             insert( boost::begin(r), boost::end(r) );
         }
 
 #endif
 
         template< class PtrSetAdapter >
         bool transfer( BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator object,
                        PtrSetAdapter& from ) // strong
         {
             return this->single_transfer( object, from );
         }
 
         template< class PtrSetAdapter >
         size_type
         transfer( BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator first,
                   BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator last,
                   PtrSetAdapter& from ) // basic
         {
             return this->single_transfer( first, last, from );
         }
 
 #if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
 #else
 
         template< class PtrSetAdapter, class Range >
         BOOST_DEDUCED_TYPENAME boost::disable_if< boost::is_same< Range,
                             BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator >,
                                                             size_type >::type
         transfer( const Range& r, PtrSetAdapter& from ) // basic
         {
             return transfer( boost::begin(r), boost::end(r), from );
         }
 
 #endif
 
         template< class PtrSetAdapter >
         size_type transfer( PtrSetAdapter& from ) // basic
         {
             return transfer( from.begin(), from.end(), from );
         }
 
     };
 
     /////////////////////////////////////////////////////////////////////////
     // ptr_multiset_adapter
     /////////////////////////////////////////////////////////////////////////
 
     template
     <
         class Key,
         class VoidPtrMultiSet,
         class CloneAllocator = heap_clone_allocator,
         bool Ordered         = true
     >
     class ptr_multiset_adapter :
         public ptr_container_detail::ptr_set_adapter_base<Key,VoidPtrMultiSet,CloneAllocator,Ordered>
     {
          typedef ptr_container_detail::ptr_set_adapter_base<Key,VoidPtrMultiSet,CloneAllocator,Ordered> base_type;
 
     public: // typedefs
 
         typedef BOOST_DEDUCED_TYPENAME base_type::iterator
                        iterator;
         typedef BOOST_DEDUCED_TYPENAME base_type::size_type
                        size_type;
         typedef Key    key_type;
         typedef BOOST_DEDUCED_TYPENAME base_type::auto_type
                        auto_type;
         typedef BOOST_DEDUCED_TYPENAME VoidPtrMultiSet::allocator_type
                        allocator_type;
     private:
         template< typename II >
         void set_basic_clone_and_insert( II first, II last ) // basic
         {
             while( first != last )
             {
                 insert( this->null_policy_allocate_clone_from_iterator( first ) ); // strong, commit
                 ++first;
             }
         }
 
     public:
         ptr_multiset_adapter()
         { }
 
         template< class SizeType >
         ptr_multiset_adapter( SizeType n,
                               ptr_container_detail::unordered_associative_container_tag tag )
           : base_type( n, tag )
         { }
 
         template< class Comp >
         explicit ptr_multiset_adapter( const Comp& comp,
                                        const allocator_type& a )
         : base_type( comp, a )
         { }
 
         template< class Hash, class Pred, class Allocator >
         ptr_multiset_adapter( const Hash& hash,
                               const Pred& pred,
                               const Allocator& a )
          : base_type( hash, pred, a )
         { }
 
         template< class InputIterator >
         ptr_multiset_adapter( InputIterator first, InputIterator last )
          : base_type( first, last )
         { }
 
         template< class InputIterator, class Comp >
         ptr_multiset_adapter( InputIterator first, InputIterator last,
                               const Comp& comp,
                               const allocator_type& a = allocator_type() )
         : base_type( comp, a )
         {
             set_basic_clone_and_insert( first, last );
         }
 
         template< class InputIterator, class Hash, class Pred, class Allocator >
         ptr_multiset_adapter( InputIterator first, InputIterator last,
                               const Hash& hash,
                               const Pred& pred,
                               const Allocator& a )
          : base_type( first, last, hash, pred, a )
         { }
 
         template< class U, class Set, class CA, bool b >
         explicit ptr_multiset_adapter( const ptr_multiset_adapter<U,Set,CA,b>& r )
           : base_type( r )
         { }
 
 #ifndef BOOST_NO_AUTO_PTR
         template< class PtrContainer >
         explicit ptr_multiset_adapter( std::auto_ptr<PtrContainer> clone )
          : base_type( clone )
         { }
 #endif
 #ifndef BOOST_NO_CXX11_SMART_PTR
         template< class PtrContainer >
         explicit ptr_multiset_adapter( std::unique_ptr<PtrContainer> clone )
          : base_type( std::move( clone ) )
         { }
 #endif
 
         template< class U, class Set, class CA, bool b >
         ptr_multiset_adapter& operator=( const ptr_multiset_adapter<U,Set,CA,b>& r )
         {
             base_type::operator=( r );
             return *this;
         }
 
 #ifndef BOOST_NO_AUTO_PTR
         template< class T >
         void operator=( std::auto_ptr<T> r )
         {
             base_type::operator=( r );
         }
 #endif
 #ifndef BOOST_NO_CXX11_SMART_PTR
         template< class T >
         void operator=( std::unique_ptr<T> r )
         {
             base_type::operator=( std::move( r ) );
         }
 #endif
 
         iterator insert( iterator before, key_type* x ) // strong
         {
             return base_type::insert( before, x );
         }
 
 #ifndef BOOST_NO_AUTO_PTR
         template< class U >
         iterator insert( iterator before, std::auto_ptr<U> x )
         {
             return insert( before, x.release() );
         }
 #endif
 #ifndef BOOST_NO_CXX11_SMART_PTR
         template< class U >
         iterator insert( iterator before, std::unique_ptr<U> x )
         {
             return insert( before, x.release() );
         }
 #endif
 
         iterator insert( key_type* x ) // strong
         {
             this->enforce_null_policy( x, "Null pointer in 'ptr_multiset::insert()'" );
 
             auto_type ptr( x, *this );
             BOOST_DEDUCED_TYPENAME base_type::ptr_iterator
                  res = this->base().insert( x );
             ptr.release();
             return iterator( res );
         }
 
 #ifndef BOOST_NO_AUTO_PTR
         template< class U >
         iterator insert( std::auto_ptr<U> x )
         {
             return insert( x.release() );
         }
 #endif
 #ifndef BOOST_NO_CXX11_SMART_PTR
         template< class U >
         iterator insert( std::unique_ptr<U> x )
         {
             return insert( x.release() );
         }
 #endif
 
         template< typename InputIterator >
         void insert( InputIterator first, InputIterator last ) // basic
         {
             set_basic_clone_and_insert( first, last );
         }
 
 #if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
 #else
 
         template< class Range >
         BOOST_DEDUCED_TYPENAME
         boost::disable_if< ptr_container_detail::is_pointer_or_integral<Range> >::type
         insert( const Range& r )
         {
             insert( boost::begin(r), boost::end(r) );
         }
 
 #endif
 
         template< class PtrSetAdapter >
         void transfer( BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator object,
                        PtrSetAdapter& from ) // strong
         {
             this->multi_transfer( object, from );
         }
 
         template< class PtrSetAdapter >
         size_type transfer( BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator first,
                             BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator last,
                             PtrSetAdapter& from ) // basic
         {
             return this->multi_transfer( first, last, from );
         }
 
 #if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
 #else
 
         template< class PtrSetAdapter, class Range >
         BOOST_DEDUCED_TYPENAME boost::disable_if< boost::is_same< Range,
                        BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator >, size_type >::type
         transfer(  const Range& r, PtrSetAdapter& from ) // basic
         {
             return transfer( boost::begin(r), boost::end(r), from );
         }
 
 #endif
 
         template< class PtrSetAdapter >
         void transfer( PtrSetAdapter& from ) // basic
         {
             transfer( from.begin(), from.end(), from );
             BOOST_ASSERT( from.empty() );
         }
 
     };
 
 } // namespace 'boost'
 
 #if defined(BOOST_PTR_CONTAINER_DISABLE_DEPRECATED)
 #pragma GCC diagnostic pop
 #endif
 
 #endif

This page was automatically generated by the 2.3.7 LXR engine. The LXR team