| // Protocol Buffers - Google's data interchange format |
| // Copyright 2008 Google Inc. |
| // http://code.google.com/p/protobuf/ |
| // |
| // 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. |
| |
| // from google3/util/gtl/stl_util-inl.h |
| |
| #ifndef GOOGLE_PROTOBUF_STUBS_STL_UTIL_INL_H__ |
| #define GOOGLE_PROTOBUF_STUBS_STL_UTIL_INL_H__ |
| |
| #include <google/protobuf/stubs/common.h> |
| |
| namespace google { |
| namespace protobuf { |
| |
| // 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; |
| } |
| } |
| |
| // Inside Google, this function implements a horrible, disgusting hack in which |
| // we reach into the string's private implementation and resize it without |
| // initializing the new bytes. In some cases doing this can significantly |
| // improve performance. However, since it's totally non-portable it has no |
| // place in open source code. Feel free to fill this function in with your |
| // own disgusting hack if you want the perf boost. |
| inline void STLStringResizeUninitialized(string* s, size_t new_size) { |
| s->resize(new_size); |
| } |
| |
| // Return a mutable char* pointing to a string's internal buffer, |
| // which may not be null-terminated. Writing through this pointer will |
| // modify the string. |
| // |
| // string_as_array(&str)[i] is valid for 0 <= i < str.size() until the |
| // next call to a string method that invalidates iterators. |
| // |
| // As of 2006-04, there is no standard-blessed way of getting a |
| // mutable reference to a string's internal buffer. However, issue 530 |
| // (http://www.open-std.org/JTC1/SC22/WG21/docs/lwg-active.html#530) |
| // proposes this as the method. According to Matt Austern, this should |
| // already work on all current implementations. |
| inline char* string_as_array(string* str) { |
| // DO NOT USE const_cast<char*>(str->data())! See the unittest for why. |
| return str->empty() ? NULL : &*str->begin(); |
| } |
| |
| // 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(); |
| } |
| |
| } // namespace protobuf |
| } // namespace google |
| |
| #endif // GOOGLE_PROTOBUF_STUBS_STL_UTIL_INL_H__ |