stl_containers_utils.h

Go to the documentation of this file.

/* +------------------------------------------------------------------------+
   |                     Mobile Robot Programming Toolkit (MRPT)            |
   |                          http://www.mrpt.org/                          |
   |                                                                        |
   | Copyright (c) 2005-2017, Individual contributors, see AUTHORS file     |
   | See: http://www.mrpt.org/Authors - All rights reserved.                |
   | Released under BSD License. See details in http://www.mrpt.org/License |
   +------------------------------------------------------------------------+ */
#pragma once

#include <list>
#include <map>
#include <set>
#include <iostream>

namespace mrpt
{
namespace utils
{
/** \addtogroup stlext_grp
  * @{ */

/** Returns the index of the value "T" in the container "vect"
 * (std::vector,std::deque,etc), or string::npos if not found.
 */
template <class T, class CONTAINER>
size_t find_in_vector(const T& value, const CONTAINER& vect)
{
        typename CONTAINER::const_iterator last = vect.end();
        for (typename CONTAINER::const_iterator i = vect.begin(); i != last; ++i)
                if (*i == value) return std::distance(vect.begin(), i);
        return std::string::npos;
}

/** Calls the standard "erase" method of a STL container, but also returns an
 * iterator to the next element in the container (or ::end if none) */
template <class T>
inline typename std::list<T>::iterator erase_return_next(
        std::list<T>& cont, typename std::list<T>::iterator& it)
{
        return cont.erase(it);
}
//! \overload
template <class K, class V>
inline typename std::map<K, V>::iterator erase_return_next(
        std::map<K, V>& cont, typename std::map<K, V>::iterator& it)
{
        typename std::map<K, V>::iterator itRet = it;
        ++itRet;
        cont.erase(it);
        return itRet;
}
//! \overload
template <class K, class V>
inline typename std::multimap<K, V>::iterator erase_return_next(
        std::multimap<K, V>& cont, typename std::multimap<K, V>::iterator& it)
{
        typename std::multimap<K, V>::iterator itRet = it;
        ++itRet;
        cont.erase(it);
        return itRet;
}
//! \overload
template <class T>
inline typename std::set<T>::iterator erase_return_next(
        std::set<T>& cont, typename std::set<T>::iterator& it)
{
        typename std::set<T>::iterator itRet = it;
        ++itRet;
        cont.erase(it);
        return itRet;
}

/**\brief Return a STL container in std::string form.
 *
 * \param[in] t Template STL container (e.g. vector)
 * \return String form of given STL container
 */
template <class T>
std::string getSTLContainerAsString(const T& t)
{
        using namespace std;
        stringstream ss;
        for (typename T::const_iterator it = t.begin(); it != t.end(); ++it)
        {
                ss << *it << ", ";
        }
        return ss.str();
}
/**\brief Print the given vector t.
 *
 * \param[in] t Template vector
 */
template <class T>
void printSTLContainer(const T& t)
{
        using namespace std;
        cout << getSTLContainerAsString(t) << endl;
}
/**\brief Print the given STL container of containers t.
 *
 * \param[in] t Template STL container (containing other containers)
 */
template <class T>
void printSTLContainerOfContainers(const T& t)
{
        using namespace std;

        int i = 0;
        for (typename T::const_iterator it = t.begin(); it != t.end(); ++i, ++it)
        {
                cout << "List " << i + 1 << "/" << t.size() << endl << "\t";
                printSTLContainer(*it);
        }
}
/**\brief Return contents of map in a string representation
 *
 * \param[in] m Template map
 * \param[in] sep String that seperates visually each key and its value.
 * Defaults to " => "
 * \return std::string representation of map
 * */
template <class T1, class T2>
std::string getMapAsString(
        const std::map<T1, T2>& m, const std::string& sep = " => ")
{
        using namespace std;
        stringstream ss("");

        for (typename map<T1, T2>::const_iterator it = m.begin(); it != m.end();
                 ++it)
        {
                ss << it->first << " => " << it->second << endl;
        }

        return ss.str();
}
/**\brief Print the given map m
 *
 * \param[in] m Template map
 */
template <class T1, class T2>
void printMap(const std::map<T1, T2>& m)
{
        using namespace std;

        cout << getMapAsString(m) << endl;
}

/** @} */  // end of grouping
}
}