Add a UniqueVector class to GN

tools/gn/target.h

 // Copyright (c) 2013 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.
 
 #ifndef TOOLS_GN_TARGET_H_
 #define TOOLS_GN_TARGET_H_
 
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/strings/string_piece.h"
 #include "base/synchronization/lock.h"
 #include "tools/gn/action_values.h"
 #include "tools/gn/config_values.h"
 #include "tools/gn/item.h"
 #include "tools/gn/label_ptr.h"
 #include "tools/gn/ordered_set.h"
 #include "tools/gn/source_file.h"
+#include "tools/gn/unique_vector.h"
 
 class InputFile;
 class Settings;
 class Token;
 
 class Target : public Item {
  public:
   enum OutputType {
     UNKNOWN,
     GROUP,
@@ skipping 65 matching lines @@
   // Linked dependencies.
   const LabelTargetVector& deps() const { return deps_; }
   LabelTargetVector& deps() { return deps_; }
 
   // Non-linked dependencies.
   const LabelTargetVector& datadeps() const { return datadeps_; }
   LabelTargetVector& datadeps() { return datadeps_; }
 
   // List of configs that this class inherits settings from. Once a target is
   // resolved, this will also list all- and direct-dependent configs.
-  const LabelConfigVector& configs() const { return configs_; }
-  LabelConfigVector& configs() { return configs_; }
+  const UniqueVector<LabelConfigPair>& configs() const { return configs_; }
+  UniqueVector<LabelConfigPair>& configs() { return configs_; }
 
   // List of configs that all dependencies (direct and indirect) of this
   // target get. These configs are not added to this target. Note that due
   // to the way this is computed, there may be duplicates in this list.
-  const LabelConfigVector& all_dependent_configs() const {
+  const UniqueVector<LabelConfigPair>& all_dependent_configs() const {
     return all_dependent_configs_;
   }
-  LabelConfigVector& all_dependent_configs() {
+  UniqueVector<LabelConfigPair>& all_dependent_configs() {
     return all_dependent_configs_;
   }
 
   // List of configs that targets depending directly on this one get. These
   // configs are not added to this target.
-  const LabelConfigVector& direct_dependent_configs() const {
+  const UniqueVector<LabelConfigPair>& direct_dependent_configs() const {
     return direct_dependent_configs_;
   }
-  LabelConfigVector& direct_dependent_configs() {
+  UniqueVector<LabelConfigPair>& direct_dependent_configs() {
     return direct_dependent_configs_;
   }
 
   // A list of a subset of deps where we'll re-export direct_dependent_configs
   // as direct_dependent_configs of this target.
-  const LabelTargetVector& forward_dependent_configs() const {
+  const UniqueVector<LabelTargetPair>& forward_dependent_configs() const {
     return forward_dependent_configs_;
   }
-  LabelTargetVector& forward_dependent_configs() {
+  UniqueVector<LabelTargetPair>& forward_dependent_configs() {
     return forward_dependent_configs_;
   }
 
-  const std::set<const Target*>& inherited_libraries() const {
+  const UniqueVector<const Target*>& inherited_libraries() const {
     return inherited_libraries_;
   }
 
   // This config represents the configuration set directly on this target.
   ConfigValues& config_values() { return config_values_; }
   const ConfigValues& config_values() const { return config_values_; }
 
   ActionValues& action_values() { return action_values_; }
   const ActionValues& action_values() const { return action_values_; }
 
   const OrderedSet<SourceDir>& all_lib_dirs() const { return all_lib_dirs_; }
   const OrderedSet<std::string>& all_libs() const { return all_libs_; }
 
   const std::set<const Target*>& recursive_hard_deps() const {
     return recursive_hard_deps_;
   }
 
  private:
   // Pulls necessary information from dependencies to this one when all
   // dependencies have been resolved.
-  void PullDependentTargetInfo(std::set<const Config*>* unique_configs);
+  void PullDependentTargetInfo();
 
   // These each pull specific things from dependencies to this one when all
   // deps have been resolved.
   void PullForwardedDependentConfigs();
   void PullRecursiveHardDeps();
 
   OutputType output_type_;
   std::string output_name_;
   std::string output_extension_;
 
@@ skipping 12 matching lines @@
   // groups of dependencies, so adding the groups deps make this happen with
   // no additional complexity when iterating over a target's deps.
   //
   // However, a group may also have specific settings and configs added to it,
   // so we also need the group in the list so we find these things. But you
   // shouldn't need to look inside the deps of the group since those will
   // already be added.
   LabelTargetVector deps_;
   LabelTargetVector datadeps_;
 
-  LabelConfigVector configs_;
-  LabelConfigVector all_dependent_configs_;
-  LabelConfigVector direct_dependent_configs_;
-  LabelTargetVector forward_dependent_configs_;
+  UniqueVector<LabelConfigPair> configs_;
+  UniqueVector<LabelConfigPair> all_dependent_configs_;
+  UniqueVector<LabelConfigPair> direct_dependent_configs_;
+  UniqueVector<LabelTargetPair> forward_dependent_configs_;
 
   bool external_;
 
   // Static libraries and source sets from transitive deps. These things need
   // to be linked only with the end target (executable, shared library). Source
   // sets do not get pushed beyond static library boundaries, and neither
   // source sets nor static libraries get pushed beyond sahred library
   // boundaries.
-  std::set<const Target*> inherited_libraries_;
+  UniqueVector<const Target*> inherited_libraries_;
 
   // These libs and dirs are inherited from statically linked deps and all
   // configs applying to this target.
   OrderedSet<SourceDir> all_lib_dirs_;
   OrderedSet<std::string> all_libs_;
 
   // All hard deps from this target and all dependencies. Filled in when this
   // target is marked resolved. This will not include the current target.
   std::set<const Target*> recursive_hard_deps_;
 
   ConfigValues config_values_;  // Used for all binary targets.
   ActionValues action_values_;  // Used for action[_foreach] targets.
 
   DISALLOW_COPY_AND_ASSIGN(Target);
 };
 
+namespace BASE_HASH_NAMESPACE {
+
+#if defined(COMPILER_GCC)
+template<> struct hash<const Target*> {
+  std::size_t operator()(const Target* t) const {
+    return reinterpret_cast<std::size_t>(t);
+  }
+};
+#elif defined(COMPILER_MSVC)
+inline size_t hash_value(const Target* t) {
+  return reinterpret_cast<size_t>(t);
+}
+#endif  // COMPILER...
+
+}  // namespace BASE_HASH_NAMESPACE
+
 #endif  // TOOLS_GN_TARGET_H_