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_