Refactor Uses of std::set to std::vector in SimpleFeature

base/stl_util.h

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Derived from google3/util/gtl/stl_util.h
 
 #ifndef BASE_STL_UTIL_H_
 #define BASE_STL_UTIL_H_
 
 #include <algorithm>
@@ skipping 72 matching lines @@
 template <class ForwardIterator>
 void STLDeleteContainerPairSecondPointers(ForwardIterator begin,
                                           ForwardIterator end) {
   while (begin != end) {
     ForwardIterator temp = begin;
     ++begin;
     delete temp->second;
   }
 }
 
+// Counts the number of instances of val in a container.
+template <typename Container, typename T>
+typename std::iterator_traits<
+    typename Container::const_iterator>::difference_type
+STLCount(const Container* const container, const T& val) {

[Lei Zhang, 2015/03/26 21:48:45]

Can |container| be a const ref instead?

[robliao, 2015/03/26 21:51:48]

My initial iteration started out like that, but I changed it to const * for the
tests. 

Check out
https://codereview.chromium.org/1032023002/diff/40001/extensions/common/featu...
for the old iteration.

The const * allows for the removal of all the * references.

[miu, 2015/03/26 22:24:43]

I gotta agree with thestig@ here.  "const Container& container" would be a
declaration that the container argument is not optional (i.e., cannot be null),
whereas the pointer version you have here leaves doubt.

[robliao, 2015/03/26 23:15:50]

Changed and Updated.

+  const typename Container::const_iterator begin = container->begin();
+  const typename Container::const_iterator end = container->end();
+  return std::count(begin, end, val);
+}
+
 // To treat a possibly-empty vector as an array, use these functions.
 // If you know the array will never be empty, you can use &*v.begin()
 // directly, but that is undefined behaviour if |v| is empty.
 template<typename T>
 inline T* vector_as_array(std::vector<T>* v) {
   return v->empty() ? NULL : &*v->begin();
 }
 
 template<typename T>
 inline const T* vector_as_array(const std::vector<T>* v) {
@@ skipping 85 matching lines @@
   T* container_;
 };
 
 // Test to see if a set, map, hash_set or hash_map contains a particular key.
 // Returns true if the key is in the collection.
 template <typename Collection, typename Key>
 bool ContainsKey(const Collection& collection, const Key& key) {
   return collection.find(key) != collection.end();
 }
 
+// Test to see if a collection like a vector contains a particular value.
+// Returns true if the value is in the collection.
+template <typename Collection, typename Value>
+bool ContainsValue(const Collection& collection, const Value& value) {
+  return std::find(collection.begin(), collection.end(), value) !=
+      collection.end();
+}
+
 namespace base {
 
 // Returns true if the container is sorted.
 template <typename Container>
 bool STLIsSorted(const Container& cont) {
   // Note: Use reverse iterator on container to ensure we only require
   // value_type to implement operator<.
   return std::adjacent_find(cont.rbegin(), cont.rend(),
                             std::less<typename Container::value_type>())
       == cont.rend();
@@ skipping 42 matching lines @@
 bool STLIncludes(const Arg1& a1, const Arg2& a2) {
   DCHECK(STLIsSorted(a1));
   DCHECK(STLIsSorted(a2));
   return std::includes(a1.begin(), a1.end(),
                        a2.begin(), a2.end());
 }
 
 }  // namespace base
 
 #endif  // BASE_STL_UTIL_H_