// Boost.Bimap | |
// | |
// Copyright (c) 2006-2007 Matias Capeletto | |
// | |
// 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) | |
/// \file container_adaptor/unordered_associative_container_adaptor.hpp | |
/// \brief Container adaptor to build a type that is compliant to the concept of an unordered associative container. | |
#ifndef BOOST_BIMAP_CONTAINER_ADAPTOR_UNORDERED_ASSOCIATIVE_CONTAINER_ADAPTOR_HPP | |
#define BOOST_BIMAP_CONTAINER_ADAPTOR_UNORDERED_ASSOCIATIVE_CONTAINER_ADAPTOR_HPP | |
#if defined(_MSC_VER) && (_MSC_VER>=1200) | |
#pragma once | |
#endif | |
#include <boost/config.hpp> | |
#include <boost/bimap/container_adaptor/associative_container_adaptor.hpp> | |
#include <boost/mpl/if.hpp> | |
#include <boost/mpl/vector.hpp> | |
#include <boost/mpl/push_front.hpp> | |
#include <boost/mpl/aux_/na.hpp> | |
#include <boost/call_traits.hpp> | |
namespace boost { | |
namespace bimaps { | |
namespace container_adaptor { | |
#ifndef BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES | |
template | |
< | |
class Base, class Iterator, class ConstIterator, | |
class LocalIterator, class ConstLocalIterator, | |
class KeyType, | |
class IteratorToBaseConverter, class IteratorFromBaseConverter, | |
class LocalIteratorFromBaseConverter, | |
class ValueToBaseConverter, class ValueFromBaseConverter, | |
class KeyToBaseConverter, | |
class FunctorsFromDerivedClasses | |
> | |
struct unordered_associative_container_adaptor_base | |
{ | |
typedef associative_container_adaptor | |
< | |
Base, Iterator, ConstIterator, KeyType, | |
IteratorToBaseConverter, IteratorFromBaseConverter, | |
ValueToBaseConverter , ValueFromBaseConverter, | |
KeyToBaseConverter, | |
BOOST_DEDUCED_TYPENAME mpl::push_front< | |
FunctorsFromDerivedClasses, | |
BOOST_DEDUCED_TYPENAME mpl::if_< | |
::boost::mpl::is_na<LocalIteratorFromBaseConverter>, | |
// { | |
detail::iterator_from_base_identity | |
< | |
BOOST_DEDUCED_TYPENAME Base::local_iterator, | |
LocalIterator, | |
BOOST_DEDUCED_TYPENAME Base::const_local_iterator, | |
ConstLocalIterator | |
>, | |
// } | |
// else | |
// { | |
LocalIteratorFromBaseConverter | |
// } | |
>::type | |
>::type | |
> type; | |
}; | |
#endif // BOOST_BIMAP_DOXYGEN_WILL_NOT_PROCESS_THE_FOLLOWING_LINES | |
/// \brief Container adaptor to build a type that is compliant to the concept of an unordered associative container. | |
template | |
< | |
class Base, | |
class Iterator, | |
class ConstIterator, | |
class LocalIterator, | |
class ConstLocalIterator, | |
class KeyType, | |
class IteratorToBaseConverter = ::boost::mpl::na, | |
class IteratorFromBaseConverter = ::boost::mpl::na, | |
class LocalIteratorFromBaseConverter = ::boost::mpl::na, | |
class ValueToBaseConverter = ::boost::mpl::na, | |
class ValueFromBaseConverter = ::boost::mpl::na, | |
class KeyToBaseConverter = ::boost::mpl::na, | |
class FunctorsFromDerivedClasses = mpl::vector<> | |
> | |
class unordered_associative_container_adaptor : | |
public unordered_associative_container_adaptor_base | |
< | |
Base, Iterator, ConstIterator, | |
LocalIterator, ConstLocalIterator, | |
KeyType, | |
IteratorToBaseConverter, IteratorFromBaseConverter, | |
LocalIteratorFromBaseConverter, | |
ValueToBaseConverter, ValueFromBaseConverter, | |
KeyToBaseConverter, | |
FunctorsFromDerivedClasses | |
>::type | |
{ | |
typedef BOOST_DEDUCED_TYPENAME unordered_associative_container_adaptor_base | |
< | |
Base, Iterator, ConstIterator, | |
LocalIterator, ConstLocalIterator, | |
KeyType, | |
IteratorToBaseConverter, IteratorFromBaseConverter, | |
LocalIteratorFromBaseConverter, | |
ValueToBaseConverter, ValueFromBaseConverter, | |
KeyToBaseConverter, | |
FunctorsFromDerivedClasses | |
>::type base_; | |
// Metadata --------------------------------------------------------------- | |
public: | |
typedef BOOST_DEDUCED_TYPENAME Base::key_equal key_equal; | |
typedef BOOST_DEDUCED_TYPENAME Base::hasher hasher; | |
typedef LocalIterator local_iterator; | |
typedef ConstLocalIterator const_local_iterator; | |
protected: | |
typedef BOOST_DEDUCED_TYPENAME mpl::if_< | |
::boost::mpl::is_na<LocalIteratorFromBaseConverter>, | |
// { | |
detail::iterator_from_base_identity | |
< | |
BOOST_DEDUCED_TYPENAME Base::local_iterator, | |
local_iterator, | |
BOOST_DEDUCED_TYPENAME Base::const_local_iterator, | |
const_local_iterator | |
>, | |
// } | |
// else | |
// { | |
LocalIteratorFromBaseConverter | |
// } | |
>::type local_iterator_from_base; | |
// Access ----------------------------------------------------------------- | |
public: | |
explicit unordered_associative_container_adaptor(Base & c) | |
: base_(c) {} | |
protected: | |
typedef unordered_associative_container_adaptor | |
unordered_associative_container_adaptor_; | |
// Interface -------------------------------------------------------------- | |
public: | |
// bucket interface: | |
BOOST_DEDUCED_TYPENAME base_::size_type bucket_count() const | |
{ | |
return this->base().bucket_count(); | |
} | |
BOOST_DEDUCED_TYPENAME base_::size_type max_bucket_count() const | |
{ | |
return this->base().max_bucket_count(); | |
} | |
BOOST_DEDUCED_TYPENAME base_::size_type bucket_size( | |
BOOST_DEDUCED_TYPENAME base_::size_type n) const | |
{ | |
return this->base().bucket_size(n); | |
} | |
template< class CompatibleKey > | |
BOOST_DEDUCED_TYPENAME base_::size_type bucket( | |
const CompatibleKey & k) const | |
{ | |
typedef BOOST_DEDUCED_TYPENAME base_::key_to_base key_to_base; | |
return this->base().bucket( | |
this->template functor<key_to_base>()(k) | |
); | |
} | |
local_iterator begin(BOOST_DEDUCED_TYPENAME base_::size_type n) | |
{ | |
return this->template functor< | |
local_iterator_from_base | |
>() ( this->base().begin(n) ); | |
} | |
const_local_iterator begin(BOOST_DEDUCED_TYPENAME base_::size_type n) const | |
{ | |
return this->template functor< | |
local_iterator_from_base | |
>() ( this->base().begin(n) ); | |
} | |
local_iterator end(BOOST_DEDUCED_TYPENAME base_::size_type n) | |
{ | |
return this->template functor< | |
local_iterator_from_base | |
>() ( this->base().end(n) ); | |
} | |
const_local_iterator end(BOOST_DEDUCED_TYPENAME base_::size_type n) const | |
{ | |
return this->template functor< | |
local_iterator_from_base | |
>() ( this->base().end(n) ); | |
} | |
// hash policy | |
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 z) | |
{ | |
return this->base().max_load_factor(z); | |
} | |
void rehash(BOOST_DEDUCED_TYPENAME base_::size_type n) | |
{ | |
return this->base().rehash(n); | |
} | |
// We have redefined end and begin so we have to manually route the old ones | |
BOOST_DEDUCED_TYPENAME base_::iterator begin() | |
{ | |
return base_::container_adaptor_::begin(); | |
} | |
BOOST_DEDUCED_TYPENAME base_::iterator end() | |
{ | |
return base_::container_adaptor_::end(); | |
} | |
BOOST_DEDUCED_TYPENAME base_::const_iterator begin() const | |
{ | |
return base_::container_adaptor_::begin(); | |
} | |
BOOST_DEDUCED_TYPENAME base_::const_iterator end() const | |
{ | |
return base_::container_adaptor_::end(); | |
} | |
}; | |
} // namespace container_adaptor | |
} // namespace bimaps | |
} // namespace boost | |
#endif // BOOST_BIMAP_CONTAINER_ADAPTOR_UNORDERED_ASSOCIATIVE_CONTAINER_ADAPTOR_HPP |