kicad/include/boost/ptr_container/detail/associative_ptr_container.hpp

412 lines
13 KiB
C++

//
// 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_DETAIL_ASSOCIATIVE_PTR_CONTAINER_HPP
#define BOOST_PTR_CONTAINER_DETAIL_ASSOCIATIVE_PTR_CONTAINER_HPP
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif
#include <boost/ptr_container/detail/reversible_ptr_container.hpp>
namespace boost
{
namespace ptr_container_detail
{
template
<
class Config,
class CloneAllocator
>
class associative_ptr_container :
public reversible_ptr_container<Config,CloneAllocator>
{
typedef reversible_ptr_container<Config,CloneAllocator>
base_type;
typedef BOOST_DEDUCED_TYPENAME base_type::scoped_deleter
scoped_deleter;
typedef BOOST_DEDUCED_TYPENAME Config::container_type
container_type;
public: // typedefs
typedef BOOST_DEDUCED_TYPENAME Config::key_type
key_type;
typedef BOOST_DEDUCED_TYPENAME Config::key_compare
key_compare;
typedef BOOST_DEDUCED_TYPENAME Config::value_compare
value_compare;
typedef BOOST_DEDUCED_TYPENAME Config::hasher
hasher;
typedef BOOST_DEDUCED_TYPENAME Config::key_equal
key_equal;
typedef BOOST_DEDUCED_TYPENAME Config::iterator
iterator;
typedef BOOST_DEDUCED_TYPENAME Config::const_iterator
const_iterator;
typedef BOOST_DEDUCED_TYPENAME Config::local_iterator
local_iterator;
typedef BOOST_DEDUCED_TYPENAME Config::const_local_iterator
const_local_iterator;
typedef BOOST_DEDUCED_TYPENAME base_type::size_type
size_type;
typedef BOOST_DEDUCED_TYPENAME base_type::reference
reference;
typedef BOOST_DEDUCED_TYPENAME base_type::const_reference
const_reference;
public: // foundation
associative_ptr_container()
{ }
template< class SizeType >
associative_ptr_container( SizeType n, unordered_associative_container_tag tag )
: base_type( n, tag )
{ }
template< class Compare, class Allocator >
associative_ptr_container( const Compare& comp,
const Allocator& a )
: base_type( comp, a, container_type() )
{ }
template< class Hash, class Pred, class Allocator >
associative_ptr_container( const Hash& hash,
const Pred& pred,
const Allocator& a )
: base_type( hash, pred, a )
{ }
template< class InputIterator, class Compare, class Allocator >
associative_ptr_container( InputIterator first, InputIterator last,
const Compare& comp,
const Allocator& a )
: base_type( first, last, comp, a, container_type() )
{ }
template< class InputIterator, class Hash, class Pred, class Allocator >
associative_ptr_container( InputIterator first, InputIterator last,
const Hash& hash,
const Pred& pred,
const Allocator& a )
: base_type( first, last, hash, pred, a )
{ }
template< class PtrContainer >
explicit associative_ptr_container( std::auto_ptr<PtrContainer> r )
: base_type( r )
{ }
associative_ptr_container( const associative_ptr_container& r )
: base_type( r.begin(), r.end(), container_type() )
{ }
template< class C, class V >
associative_ptr_container( const associative_ptr_container<C,V>& r )
: base_type( r.begin(), r.end(), container_type() )
{ }
template< class PtrContainer >
associative_ptr_container& operator=( std::auto_ptr<PtrContainer> r ) // nothrow
{
base_type::operator=( r );
return *this;
}
associative_ptr_container& operator=( associative_ptr_container r ) // strong
{
this->swap( r );
return *this;
}
public: // associative container interface
key_compare key_comp() const
{
return this->base().key_comp();
}
value_compare value_comp() const
{
return this->base().value_comp();
}
iterator erase( iterator before ) // nothrow
{
BOOST_ASSERT( !this->empty() );
BOOST_ASSERT( before != this->end() );
this->remove( before ); // nothrow
iterator res( before ); // nothrow
++res; // nothrow
this->base().erase( before.base() ); // nothrow
return res; // nothrow
}
size_type erase( const key_type& x ) // nothrow
{
iterator i( this->base().find( x ) );
// nothrow
if( i == this->end() ) // nothrow
return 0u; // nothrow
this->remove( i ); // nothrow
return this->base().erase( x ); // nothrow
}
iterator erase( iterator first,
iterator last ) // nothrow
{
iterator res( last ); // nothrow
if( res != this->end() )
++res; // nothrow
this->remove( first, last ); // nothrow
this->base().erase( first.base(), last.base() ); // nothrow
return res; // nothrow
}
#if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
#else
template< class Range >
BOOST_DEDUCED_TYPENAME boost::disable_if< boost::is_convertible<Range&,key_type&>,
iterator >::type
erase( const Range& r )
{
return erase( boost::begin(r), boost::end(r) );
}
#endif
protected:
template< class AssociatePtrCont >
void multi_transfer( BOOST_DEDUCED_TYPENAME AssociatePtrCont::iterator object,
AssociatePtrCont& from ) // strong
{
BOOST_ASSERT( (void*)&from != (void*)this );
BOOST_ASSERT( !from.empty() && "Cannot transfer from empty container" );
this->base().insert( *object.base() ); // strong
from.base().erase( object.base() ); // nothrow
}
template< class AssociatePtrCont >
size_type multi_transfer( BOOST_DEDUCED_TYPENAME AssociatePtrCont::iterator first,
BOOST_DEDUCED_TYPENAME AssociatePtrCont::iterator last,
AssociatePtrCont& from ) // basic
{
BOOST_ASSERT( (void*)&from != (void*)this );
size_type res = 0;
for( ; first != last; )
{
BOOST_ASSERT( first != from.end() );
this->base().insert( *first.base() ); // strong
BOOST_DEDUCED_TYPENAME AssociatePtrCont::iterator
to_delete( first );
++first;
from.base().erase( to_delete.base() ); // nothrow
++res;
}
return res;
}
template< class AssociatePtrCont >
bool single_transfer( BOOST_DEDUCED_TYPENAME AssociatePtrCont::iterator object,
AssociatePtrCont& from ) // strong
{
BOOST_ASSERT( (void*)&from != (void*)this );
BOOST_ASSERT( !from.empty() && "Cannot transfer from empty container" );
std::pair<BOOST_DEDUCED_TYPENAME base_type::ptr_iterator,bool> p =
this->base().insert( *object.base() ); // strong
if( p.second )
from.base().erase( object.base() ); // nothrow
return p.second;
}
template< class AssociatePtrCont >
size_type single_transfer( BOOST_DEDUCED_TYPENAME AssociatePtrCont::iterator first,
BOOST_DEDUCED_TYPENAME AssociatePtrCont::iterator last,
AssociatePtrCont& from ) // basic
{
BOOST_ASSERT( (void*)&from != (void*)this );
size_type res = 0;
for( ; first != last; )
{
BOOST_ASSERT( first != from.end() );
std::pair<BOOST_DEDUCED_TYPENAME base_type::ptr_iterator,bool> p =
this->base().insert( *first.base() ); // strong
BOOST_DEDUCED_TYPENAME AssociatePtrCont::iterator
to_delete( first );
++first;
if( p.second )
{
from.base().erase( to_delete.base() ); // nothrow
++res;
}
}
return res;
}
reference front()
{
BOOST_ASSERT( !this->empty() );
BOOST_ASSERT( *this->begin().base() != 0 );
return *this->begin();
}
const_reference front() const
{
return const_cast<associative_ptr_container*>(this)->front();
}
reference back()
{
BOOST_ASSERT( !this->empty() );
BOOST_ASSERT( *(--this->end()).base() != 0 );
return *--this->end();
}
const_reference back() const
{
return const_cast<associative_ptr_container*>(this)->back();
}
protected: // unordered interface
hasher hash_function() const
{
return this->base().hash_function();
}
key_equal key_eq() const
{
return this->base().key_eq();
}
size_type bucket_count() const
{
return this->base().bucket_count();
}
size_type max_bucket_count() const
{
return this->base().max_bucket_count();
}
size_type bucket_size( size_type n ) const
{
return this->base().bucket_size( n );
}
float load_factor() const
{
return this->base().load_factor();
}
float max_load_factor() const
{
return this->base().max_load_factor();
}
void max_load_factor( float factor )
{
return this->base().max_load_factor( factor );
}
void rehash( size_type n )
{
this->base().rehash( n );
}
public:
#if BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(70190006))
iterator begin()
{
return base_type::begin();
}
const_iterator begin() const
{
return base_type::begin();
}
iterator end()
{
return base_type::end();
}
const_iterator end() const
{
return base_type::end();
}
const_iterator cbegin() const
{
return base_type::cbegin();
}
const_iterator cend() const
{
return base_type::cend();
}
#else
using base_type::begin;
using base_type::end;
using base_type::cbegin;
using base_type::cend;
#endif
protected:
local_iterator begin( size_type n )
{
return local_iterator( this->base().begin( n ) );
}
const_local_iterator begin( size_type n ) const
{
return const_local_iterator( this->base().begin( n ) );
}
local_iterator end( size_type n )
{
return local_iterator( this->base().end( n ) );
}
const_local_iterator end( size_type n ) const
{
return const_local_iterator( this->base().end( n ) );
}
const_local_iterator cbegin( size_type n ) const
{
return const_local_iterator( this->base().cbegin( n ) );
}
const_local_iterator cend( size_type n )
{
return const_local_iterator( this->base().cend( n ) );
}
}; // class 'associative_ptr_container'
} // namespace 'ptr_container_detail'
} // namespace 'boost'
#endif