/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef ART_RUNTIME_BASE_STL_UTIL_H_ #define ART_RUNTIME_BASE_STL_UTIL_H_ #include <algorithm> #include <sstream> namespace art { // Sort and remove duplicates of an STL vector or deque. template<class T> void STLSortAndRemoveDuplicates(T* v) { std::sort(v->begin(), v->end()); v->erase(std::unique(v->begin(), v->end()), v->end()); } // STLDeleteContainerPointers() // For a range within a container of pointers, calls delete // (non-array version) on these pointers. // NOTE: for these three functions, we could just implement a DeleteObject // functor and then call for_each() on the range and functor, but this // requires us to pull in all of algorithm.h, which seems expensive. // For hash_[multi]set, it is important that this deletes behind the iterator // because the hash_set may call the hash function on the iterator when it is // advanced, which could result in the hash function trying to deference a // stale pointer. template <class ForwardIterator> void STLDeleteContainerPointers(ForwardIterator begin, ForwardIterator end) { while (begin != end) { ForwardIterator temp = begin; ++begin; delete *temp; } } // STLDeleteElements() deletes all the elements in an STL container and clears // the container. This function is suitable for use with a vector, set, // hash_set, or any other STL container which defines sensible begin(), end(), // and clear() methods. // // If container is NULL, this function is a no-op. // // As an alternative to calling STLDeleteElements() directly, consider // ElementDeleter (defined below), which ensures that your container's elements // are deleted when the ElementDeleter goes out of scope. template <class T> void STLDeleteElements(T *container) { if (!container) return; STLDeleteContainerPointers(container->begin(), container->end()); container->clear(); } // Given an STL container consisting of (key, value) pairs, STLDeleteValues // deletes all the "value" components and clears the container. Does nothing // in the case it's given a NULL pointer. template <class T> void STLDeleteValues(T *v) { if (!v) return; for (typename T::iterator i = v->begin(); i != v->end(); ++i) { delete i->second; } v->clear(); } template <class T> std::string ToString(const T& v) { std::ostringstream os; os << "["; for (size_t i = 0; i < v.size(); ++i) { os << v[i]; if (i < v.size() - 1) { os << ", "; } } os << "]"; return os.str(); } } // namespace art #endif // ART_RUNTIME_BASE_STL_UTIL_H_