boost/bimap/container_adaptor/sequence_container_adaptor.hpp
// 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/sequence_container_adaptor.hpp
/// \brief Container adaptor to build a type that is compliant to the concept of a weak associative container.
#ifndef BOOST_BIMAP_CONTAINER_ADAPTOR_SEQUENCE_CONTAINER_ADAPTOR_HPP
#define BOOST_BIMAP_CONTAINER_ADAPTOR_SEQUENCE_CONTAINER_ADAPTOR_HPP
#if defined(_MSC_VER) && (_MSC_VER>=1200)
#pragma once
#endif
#include <boost/config.hpp>
#include <utility>
#include <boost/mpl/if.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/mpl/aux_/na.hpp>
#include <boost/bimap/container_adaptor/detail/identity_converters.hpp>
#include <boost/bimap/container_adaptor/container_adaptor.hpp>
#include <boost/call_traits.hpp>
#include <boost/operators.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 ReverseIterator, class ConstReverseIterator,
class IteratorToBaseConverter, class IteratorFromBaseConverter,
class ReverseIteratorFromBaseConverter,
class ValueToBaseConverter, class ValueFromBaseConverter,
class FunctorsFromDerivedClasses
>
struct sequence_container_adaptor_base
{
typedef container_adaptor
<
Base, Iterator, ConstIterator,
IteratorToBaseConverter, IteratorFromBaseConverter,
ValueToBaseConverter, ValueFromBaseConverter,
BOOST_DEDUCED_TYPENAME mpl::push_front<
FunctorsFromDerivedClasses,
BOOST_DEDUCED_TYPENAME mpl::if_<
::boost::mpl::is_na<ReverseIteratorFromBaseConverter>,
// {
detail::iterator_from_base_identity
<
BOOST_DEDUCED_TYPENAME Base::reverse_iterator,
ReverseIterator,
BOOST_DEDUCED_TYPENAME Base::const_reverse_iterator,
ConstReverseIterator
>,
// }
// else
// {
ReverseIteratorFromBaseConverter
// }
>::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 a sequence container.
template
<
class Base,
class Iterator,
class ConstIterator,
class ReverseIterator,
class ConstReverseIterator,
class IteratorToBaseConverter = ::boost::mpl::na,
class IteratorFromBaseConverter = ::boost::mpl::na,
class ReverseIteratorFromBaseConverter = ::boost::mpl::na,
class ValueToBaseConverter = ::boost::mpl::na,
class ValueFromBaseConverter = ::boost::mpl::na,
class FunctorsFromDerivedClasses = mpl::vector<>
>
class sequence_container_adaptor :
public sequence_container_adaptor_base
<
Base, Iterator, ConstIterator,
ReverseIterator, ConstReverseIterator,
IteratorToBaseConverter, IteratorFromBaseConverter,
ReverseIteratorFromBaseConverter,
ValueToBaseConverter, ValueFromBaseConverter,
FunctorsFromDerivedClasses
>::type,
::boost::totally_ordered
<
sequence_container_adaptor
<
Base, Iterator, ConstIterator,
ReverseIterator, ConstReverseIterator,
IteratorToBaseConverter, IteratorFromBaseConverter,
ReverseIteratorFromBaseConverter,
ValueToBaseConverter, ValueFromBaseConverter,
FunctorsFromDerivedClasses
>
>
{
typedef BOOST_DEDUCED_TYPENAME sequence_container_adaptor_base
<
Base, Iterator, ConstIterator,
ReverseIterator, ConstReverseIterator,
IteratorToBaseConverter, IteratorFromBaseConverter,
ReverseIteratorFromBaseConverter,
ValueToBaseConverter, ValueFromBaseConverter,
FunctorsFromDerivedClasses
>::type base_;
// MetaData -------------------------------------------------------------
public:
typedef ReverseIterator reverse_iterator;
typedef ConstReverseIterator const_reverse_iterator;
protected:
typedef BOOST_DEDUCED_TYPENAME mpl::if_<
::boost::mpl::is_na<ReverseIteratorFromBaseConverter>,
// {
detail::iterator_from_base_identity
<
BOOST_DEDUCED_TYPENAME Base::reverse_iterator,
reverse_iterator,
BOOST_DEDUCED_TYPENAME Base::const_reverse_iterator,
const_reverse_iterator
>,
// }
// else
// {
ReverseIteratorFromBaseConverter
// }
>::type reverse_iterator_from_base;
// Access -----------------------------------------------------------------
public:
explicit sequence_container_adaptor(Base & c)
: base_(c) {}
protected:
typedef sequence_container_adaptor sequence_container_adaptor_;
// Interface --------------------------------------------------------------
public:
reverse_iterator rbegin()
{
return this->template functor<
reverse_iterator_from_base
>() ( this->base().rbegin() );
}
reverse_iterator rend()
{
return this->template functor<
reverse_iterator_from_base
>() ( this->base().rend() );
}
const_reverse_iterator rbegin() const
{
return this->template functor<
reverse_iterator_from_base
>() ( this->base().rbegin() );
}
const_reverse_iterator rend() const
{
return this->template functor<
reverse_iterator_from_base
>() ( this->base().rend() );
}
void resize(BOOST_DEDUCED_TYPENAME base_::size_type n,
BOOST_DEDUCED_TYPENAME ::boost::call_traits<
BOOST_DEDUCED_TYPENAME base_::value_type >::param_type x =
BOOST_DEDUCED_TYPENAME base_::value_type())
{
this->base().resize(n,
this->template functor<BOOST_DEDUCED_TYPENAME base_::value_to_base>()(x)
);
}
BOOST_DEDUCED_TYPENAME base_::reference front()
{
return this->template functor<
BOOST_DEDUCED_TYPENAME base_::value_from_base>()
(
this->base().front()
);
}
BOOST_DEDUCED_TYPENAME base_::reference back()
{
return this->template functor<
BOOST_DEDUCED_TYPENAME base_::value_from_base>()
(
this->base().back()
);
}
BOOST_DEDUCED_TYPENAME base_::const_reference front() const
{
return this->template functor<
BOOST_DEDUCED_TYPENAME base_::value_from_base>()
(
this->base().front()
);
}
BOOST_DEDUCED_TYPENAME base_::const_reference back() const
{
return this->template functor<
BOOST_DEDUCED_TYPENAME base_::value_from_base>()
(
this->base().back()
);
}
void push_front(
BOOST_DEDUCED_TYPENAME ::boost::call_traits<
BOOST_DEDUCED_TYPENAME base_::value_type >::param_type x)
{
this->base().push_front(
this->template functor<BOOST_DEDUCED_TYPENAME base_::value_to_base>()(x));
}
void pop_front()
{
this->base().pop_front();
}
void push_back(
BOOST_DEDUCED_TYPENAME ::boost::call_traits<
BOOST_DEDUCED_TYPENAME base_::value_type >::param_type x)
{
this->base().push_back(
this->template functor<BOOST_DEDUCED_TYPENAME base_::value_to_base>()(x));
}
void pop_back()
{
this->base().pop_back();
}
std::pair<BOOST_DEDUCED_TYPENAME base_::iterator,bool>
insert(BOOST_DEDUCED_TYPENAME base_::iterator position,
BOOST_DEDUCED_TYPENAME ::boost::call_traits<
BOOST_DEDUCED_TYPENAME base_::value_type >::param_type x)
{
std::pair< BOOST_DEDUCED_TYPENAME Base::iterator, bool > r(
this->base().insert(
this->template functor<
BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(position),
this->template functor<
BOOST_DEDUCED_TYPENAME base_::value_to_base >()(x)
)
);
return std::pair<BOOST_DEDUCED_TYPENAME base_::iterator, bool>(
this->template functor<
BOOST_DEDUCED_TYPENAME base_::iterator_from_base>()(r.first),
r.second
);
}
void insert(BOOST_DEDUCED_TYPENAME base_::iterator position,
BOOST_DEDUCED_TYPENAME base_::size_type m,
BOOST_DEDUCED_TYPENAME ::boost::call_traits<
BOOST_DEDUCED_TYPENAME base_::value_type >::param_type x)
{
this->base().insert(
this->template functor<
BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()(position),
m,
this->template functor<BOOST_DEDUCED_TYPENAME base_::value_to_base >()(x)
);
}
template< class InputIterator >
void insert(BOOST_DEDUCED_TYPENAME base_::iterator position,
InputIterator first, InputIterator last)
{
// This is the same problem found in the insert function
// of container_adaptor
// For now, do the simple thing. This can be optimized
for( ; first != last ; ++first )
{
this->base().insert(
this->template functor<
BOOST_DEDUCED_TYPENAME base_::iterator_to_base>()( position ),
this->template functor<
BOOST_DEDUCED_TYPENAME base_::value_to_base >()( *first )
);
}
}
// Totally ordered implementation
bool operator==(const sequence_container_adaptor & c) const
{
return ( this->base() == c.base() );
}
bool operator<(const sequence_container_adaptor & c) const
{
return ( this->base() < c.base() );
}
};
} // namespace container_adaptor
} // namespace bimaps
} // namespace boost
#endif // BOOST_BIMAP_CONTAINER_ADAPTOR_SEQUENCE_CONTAINER_ADAPTOR_HPP