stlContainerUtils.h

Go to the documentation of this file.

#ifndef CARMA_UTIL_STLCONTAINERUTILS_H
#define CARMA_UTIL_STLCONTAINERUTILS_H


#include <algorithm>
#include <iterator>
#include <map>
#include <set>


namespace carma {
namespace util {


template < typename C >
bool sizeIsExactlyOne( const C & );


template < typename C >
bool sizeIsOneOrLess( const C & );


template < typename K, typename V >
::std::multimap< V, K > invertToMultimap( const ::std::map< K, V > & in );


template < typename K, typename V >
::std::multimap< V, K > invertToMultimap( const ::std::multimap< K, V > & in );


template < typename K, typename V >
::std::set< K > keys( const ::std::map< K, V > & in );

template < typename K, typename V >
::std::set< K > keys( const ::std::multimap< K, V > & in );

//@see carma::util::keys()
struct RetrieveKey {
    template< typename T >
    typename T::first_type operator()(T keyValuePair ) const {
        return keyValuePair.first;
    }
};
}  // namespace carma::util
}  // namespace carma



template < typename C >
bool
carma::util::sizeIsExactlyOne( const C & c )
{
    if ( c.empty() )  // constant time
        return false;

    typename C::const_iterator i = c.begin();  // constant time

    ++i;  // constant time

    return (i == c.end());  // constant time
}


template < typename C >
bool
carma::util::sizeIsOneOrLess( const C & c )
{
    if ( c.empty() )  // constant time
        return true;

    typename C::const_iterator i = c.begin();  // constant time

    ++i;  // constant time

    return (i == c.end());  // constant time
}


template < typename K, typename V >
::std::multimap< V, K >
carma::util::invertToMultimap( const ::std::map< K, V > & in )
{
    ::std::multimap< V, K > out;

    typename ::std::map< K, V >::const_iterator i = in.begin();
    const typename  ::std::map< K, V >::const_iterator iEnd = in.end();

    for ( ; i != iEnd; ++i )
        out.insert( ::std::make_pair( i->second, i->first ) );

    return out;
}


template < typename K, typename V >
::std::multimap< V, K >
carma::util::invertToMultimap( const ::std::multimap< K, V > & in )
{
    ::std::multimap< V, K > out;

    typename ::std::multimap< K, V >::const_iterator i = in.begin();
    const typename ::std::multimap< K, V >::const_iterator iEnd = in.end();

    for ( ; i != iEnd; ++i )
        out.insert( ::std::make_pair( i->second, i->first ) );

    return out;
}

template < typename K, typename V >
::std::set< K > carma::util::keys( const ::std::map< K, V > & in ) 
{
    ::std::set< K > out;
    transform( in.begin(), in.end(), 
               inserter( out, out.begin() ), RetrieveKey() 
             );
    return out;
}

template < typename K, typename V >
::std::set< K > carma::util::keys( const ::std::multimap< K, V > & in ) 
{
    ::std::set< K > out;
    // this is somewhat inefficient since identical keys are multiply
    // retrieved.  
    transform( in.begin(), in.end(), 
               inserter( out, out.begin() ), RetrieveKey() 
             );
    return out;
}


#endif