// 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/associative_container_adaptor.hpp

/// \brief Container adaptor to build a type that is compliant to the concept of an associative container.



#ifndef BOOST_BIMAP_CONTAINER_ADAPTOR_ASSOCIATIVE_CONTAINER_ADAPTOR_HPP

#define BOOST_BIMAP_CONTAINER_ADAPTOR_ASSOCIATIVE_CONTAINER_ADAPTOR_HPP



#if defined(_MSC_VER) && (_MSC_VER>=1200)

#pragma once

#endif



#include <boost/config.hpp>



#include <utility>



#include <boost/mpl/vector.hpp>

#include <boost/mpl/if.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>



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 KeyType,

    class IteratorToBaseConverter, class IteratorFromBaseConverter,

    class ValueToBaseConverter, class ValueFromBaseConverter, class KeyToBaseConverter,

    class FunctorsFromDerivedClasses

>

struct associative_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<KeyToBaseConverter>,

            // {

                    detail::key_to_base_identity

                    <

                        BOOST_DEDUCED_TYPENAME Base::key_type, KeyType

                    >,

            // }

            // else

            // {

                    KeyToBaseConverter

            // }



            >::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 associative container.



template

<

    class Base,



    class Iterator,

    class ConstIterator,



    class KeyType,



    class IteratorToBaseConverter   = ::boost::mpl::na,

    class IteratorFromBaseConverter = ::boost::mpl::na,

    class ValueToBaseConverter      = ::boost::mpl::na,

    class ValueFromBaseConverter    = ::boost::mpl::na,

    class KeyToBaseConverter        = ::boost::mpl::na,



    class FunctorsFromDerivedClasses = mpl::vector<>

>

class associative_container_adaptor :



    public associative_container_adaptor_base

    <

        Base, Iterator, ConstIterator, KeyType,

        IteratorToBaseConverter, IteratorFromBaseConverter,

        ValueToBaseConverter, ValueFromBaseConverter, KeyToBaseConverter,

        FunctorsFromDerivedClasses



    >::type

{



    // MetaData -------------------------------------------------------------



    typedef typename associative_container_adaptor_base

    <

        Base, Iterator, ConstIterator, KeyType,

        IteratorToBaseConverter, IteratorFromBaseConverter,

        ValueToBaseConverter, ValueFromBaseConverter, KeyToBaseConverter,

        FunctorsFromDerivedClasses



    >::type base_;



    public:



    typedef KeyType key_type;



    protected:



    typedef BOOST_DEDUCED_TYPENAME mpl::if_< ::boost::mpl::is_na<KeyToBaseConverter>,

    // {

            detail::key_to_base_identity

            <

                BOOST_DEDUCED_TYPENAME Base::key_type, KeyType

            >,

    // }

    // else

    // {

            KeyToBaseConverter

    // }



    >::type key_to_base;



    public:



    explicit associative_container_adaptor(Base & c)

        : base_(c) {}



    protected:





    typedef associative_container_adaptor associative_container_adaptor_;



    // Interface --------------------------------------------------------------



    public:



    template< class CompatibleKey >

    BOOST_DEDUCED_TYPENAME base_::size_type erase(const CompatibleKey & k)

    {

        return this->base().erase

        (

            this->template functor<key_to_base>()(k)

        );

    }



    // As we redefine erase, the other overloads need to be manually routed



    BOOST_DEDUCED_TYPENAME base_::iterator erase(

        BOOST_DEDUCED_TYPENAME base_::iterator pos)

    {

        return base_::container_adaptor_::erase(pos);

    }



    BOOST_DEDUCED_TYPENAME base_::iterator erase(

        BOOST_DEDUCED_TYPENAME base_::iterator first,

        BOOST_DEDUCED_TYPENAME base_::iterator last)

    {

        return base_::container_adaptor_::erase(first,last);

    }



    template< class CompatibleKey >

    BOOST_DEDUCED_TYPENAME base_::size_type count(const CompatibleKey & k)

    {

        return this->base().count(

            this->template functor<key_to_base>()(k)

        );

    }



    template< class CompatibleKey >

    BOOST_DEDUCED_TYPENAME base_::iterator find(const CompatibleKey & k)

    {

        return this->template functor<typename base_::iterator_from_base>()

        (

            this->base().find(

                this->template functor<key_to_base>()(k)

            )

        );

    }



    template< class CompatibleKey >

    BOOST_DEDUCED_TYPENAME base_::const_iterator

        find(const CompatibleKey & k) const

    {

        return this->template functor<

            BOOST_DEDUCED_TYPENAME base_::iterator_from_base>()

        (

            this->base().find(

                this->template functor<key_to_base>()(k)

            )

        );

    }



    template< class CompatibleKey >

    std::pair

    <

        BOOST_DEDUCED_TYPENAME base_::iterator,

        BOOST_DEDUCED_TYPENAME base_::iterator

    >

        equal_range(const CompatibleKey & k)

    {

        std::pair<



            BOOST_DEDUCED_TYPENAME Base::iterator,

            BOOST_DEDUCED_TYPENAME Base::iterator



        > r( this->base().equal_range(

                this->template functor<key_to_base>()(k)

            )

        );



        return std::pair

        <

            BOOST_DEDUCED_TYPENAME base_::iterator,

            BOOST_DEDUCED_TYPENAME base_::iterator

        >(

            this->template functor<

                BOOST_DEDUCED_TYPENAME base_::iterator_from_base

            >()                                         ( r.first ),

            this->template functor<

                BOOST_DEDUCED_TYPENAME base_::iterator_from_base

            >()                                         ( r.second )

        );

    }



    template< class CompatibleKey >

    std::pair

    <

        BOOST_DEDUCED_TYPENAME base_::const_iterator,

        BOOST_DEDUCED_TYPENAME base_::const_iterator

    >

        equal_range(const CompatibleKey & k) const

    {

        std::pair<



            BOOST_DEDUCED_TYPENAME Base::const_iterator,

            BOOST_DEDUCED_TYPENAME Base::const_iterator



        > r( this->base().equal_range(

                this->template functor<key_to_base>()(k)

            )

        );



        return std::pair

        <

            BOOST_DEDUCED_TYPENAME base_::const_iterator,

            BOOST_DEDUCED_TYPENAME base_::const_iterator

        >(

            this->template functor<

                BOOST_DEDUCED_TYPENAME base_::iterator_from_base

            >()                                         ( r.first ),

            this->template functor<

                BOOST_DEDUCED_TYPENAME base_::iterator_from_base

            >()                                         ( r.second )

        );

    }



};





} // namespace container_adaptor

} // namespace bimaps

} // namespace boost





#endif // BOOST_BIMAP_CONTAINER_ADAPTOR_ASSOCIATIVE_CONTAINER_ADAPTOR_HPP







