STLUtils.h

Go to the documentation of this file.

/*
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 *
 * STLUtils.h
 * Helper functions for dealing with the STL.
 * Copyright (C) 2012 Simon Newton
 */

#ifndef INCLUDE_OLA_STL_STLUTILS_H_
#define INCLUDE_OLA_STL_STLUTILS_H_

#include <assert.h>
#include <cstddef>
#include <map>
#include <set>
#include <vector>
#include <utility>

namespace ola {

template<typename T>
void STLEmptyStack(T *stack) {
 while (!stack->empty()) {
 stack->pop();
 }
}

template<typename T>
void STLEmptyStackAndDelete(T *stack) {
 while (!stack->empty()) {
 delete stack->top();
 stack->pop();
 }
}

template<typename T>
void STLDeleteElements(T *sequence) {
 typename T::iterator iter = sequence->begin();
 for (; iter != sequence->end(); ++iter) {
 if (*iter) {
 delete *iter;
 }
 }
 sequence->clear();
}

template<typename T>
void STLDeleteValues(T *container) {
 typename T::iterator iter = container->begin();
 for (; iter != container->end(); ++iter) {
 if (iter->second) {
 delete iter->second;
 }
 }
 container->clear();
}

template<typename T1, typename T2>
inline bool STLContains(const T1 &container, const T2 &value) {
 return container.find(value) != container.end();
}

template<typename T1>
void STLKeys(const T1 &container, std::vector<typename T1::key_type> *keys) {
 keys->reserve(keys->size() + container.size());
 typename T1::const_iterator iter = container.begin();
 for (; iter != container.end(); ++iter)
 keys->push_back(iter->first);
}

template<typename T1, typename T2>
void STLValues(const T1 &container, std::vector<T2> *values) {
 values->reserve(values->size() + container.size());
 typename T1::const_iterator iter = container.begin();
 for (; iter != container.end(); ++iter)
 values->push_back(iter->second);
}

template<typename T1>
typename T1::mapped_type* STLFind(T1 *container,
 const typename T1::key_type &key) {
 typename T1::iterator iter = container->find(key);
 if (iter == container->end()) {
 return NULL;
 } else {
 return &iter->second;
 }
}

template<typename T1>
typename T1::mapped_type const* STLFind(const T1 *container,
 const typename T1::key_type &key) {
 typename T1::const_iterator iter = container->find(key);
 if (iter == container->end()) {
 return NULL;
 } else {
 return &iter->second;
 }
}

template<typename T1>
typename T1::mapped_type STLFindOrNull(const T1 &container,
 const typename T1::key_type &key) {
 typename T1::const_iterator iter = container.find(key);
 if (iter == container.end()) {
 return NULL;
 } else {
 return iter->second;
 }
}


template<typename T1>
bool STLReplace(T1 *container, const typename T1::key_type &key,
 const typename T1::mapped_type &value) {
 std::pair<typename T1::iterator, bool> p = container->insert(
 typename T1::value_type(key, value));
 if (!p.second) {
 p.first->second = value;
 return true;
 }
 return false;
}

template<typename T1>
typename T1::mapped_type STLReplacePtr(T1 *container,
 const typename T1::key_type &key,
 const typename T1::mapped_type &value) {
 std::pair<typename T1::iterator, bool> p = container->insert(
 typename T1::value_type(key, value));
 if (!p.second) {
 typename T1::mapped_type old_value = p.first->second;
 p.first->second = value;
 return old_value;
 }
 return NULL;
}


template<typename T1>
bool STLReplaceAndDelete(T1 *container, const typename T1::key_type &key,
 const typename T1::mapped_type &value) {
 std::pair<typename T1::iterator, bool> p = container->insert(
 typename T1::value_type(key, value));
 if (!p.second) {
 delete p.first->second;
 p.first->second = value;
 return true;
 }
 return false;
}


template<typename T1>
bool STLInsertIfNotPresent(T1 *container,
 const typename T1::value_type &key_value) {
 return container->insert(key_value).second;
}


template<typename T1>
bool STLInsertIfNotPresent(T1 *container, const typename T1::key_type &key,
 const typename T1::mapped_type &value) {
 return container->insert(typename T1::value_type(key, value)).second;
}


template<typename T1>
void STLInsertOrDie(T1 *container, const typename T1::key_type &key,
 const typename T1::mapped_type &value) {
 assert(container->insert(typename T1::value_type(key, value)).second);
}


template<typename T1>
bool STLRemove(T1 *container, const typename T1::key_type &key) {
 return container->erase(key);
}

template<typename T1>
bool STLLookupAndRemove(T1 *container,
 const typename T1::key_type &key,
 typename T1::mapped_type *value) {
 typename T1::iterator iter = container->find(key);
 if (iter == container->end()) {
 return false;
 } else {
 *value = iter->second;
 container->erase(iter);
 return true;
 }
}

template<typename T1>
typename T1::iterator STLLookupOrInsertNull(T1 *container,
 const typename T1::key_type &key) {
 std::pair<typename T1::iterator, bool> p = container->insert(
 typename T1::value_type(key, NULL));
 return p.first;
}

template<typename T1>
void PairAssociativeAssignNew(T1 **location) {
 *location = new T1();
}

template<typename T1>
typename T1::iterator STLLookupOrInsertNew(T1 *container,
 const typename T1::key_type &key) {
 std::pair<typename T1::iterator, bool> p = container->insert(
 typename T1::value_type(key, NULL));
 if (p.second) {
 PairAssociativeAssignNew(&p.first->second);
 }
 return p.first;
}

template<typename T1>
bool STLRemoveAndDelete(T1 *container, const typename T1::key_type &key) {
 typename T1::iterator iter = container->find(key);
 if (iter == container->end()) {
 return false;
 } else {
 delete iter->second;
 container->erase(iter);
 return true;
 }
}

template<typename T1>
typename T1::mapped_type STLLookupAndRemovePtr(
 T1 *container,
 const typename T1::key_type &key) {
 typename T1::iterator iter = container->find(key);
 if (iter == container->end()) {
 return NULL;
 } else {
 typename T1::mapped_type value = iter->second;
 container->erase(iter);
 return value;
 }
}

template<typename T1, typename T2>
void STLMapFromKeys(T1 *output, const T2 input,
 typename T1::mapped_type value) {
 typename T2::const_iterator iter = input.begin();
 for (; iter != input.end(); ++iter) {
 std::pair<typename T1::iterator, bool> p = output->insert(
 typename T1::value_type(*iter, value));
 if (!p.second) {
 p.first->second = value;
 }
 }
}
} // namespace ola
#endif // INCLUDE_OLA_STL_STLUTILS_H_