Use Google3 style guide with .clang-format

Test: style change only, builds ok
Change-Id: I885180e24cb2e7b58cfb4967c3bcb40058ce4078

1 files changed, 167 insertions, 169 deletions

diff --git a/tools/aapt2/StringPool.h b/tools/aapt2/StringPool.h
index 13545bef53ab..05c26e7e4ea1 100644
--- a/tools/aapt2/StringPool.h
+++ b/tools/aapt2/StringPool.h
@@ -17,207 +17,205 @@
 #ifndef AAPT_STRING_POOL_H
 #define AAPT_STRING_POOL_H
 
-#include "util/BigBuffer.h"
 #include "ConfigDescription.h"
+#include "util/BigBuffer.h"
 #include "util/StringPiece.h"
 
 #include <functional>
-#include <unordered_map>
 #include <memory>
 #include <string>
+#include <unordered_map>
 #include <vector>
 
 namespace aapt {
 
 struct Span {
-    std::string name;
-    uint32_t firstChar;
-    uint32_t lastChar;
+  std::string name;
+  uint32_t firstChar;
+  uint32_t lastChar;
 };
 
 struct StyleString {
-    std::string str;
-    std::vector<Span> spans;
+  std::string str;
+  std::vector<Span> spans;
 };
 
 class StringPool {
-public:
-    struct Context {
-        uint32_t priority;
-        ConfigDescription config;
-    };
+ public:
+  struct Context {
+    uint32_t priority;
+    ConfigDescription config;
+  };
+
+  class Entry;
+
+  class Ref {
+   public:
+    Ref();
+    Ref(const Ref&);
+    ~Ref();
+
+    Ref& operator=(const Ref& rhs);
+    const std::string* operator->() const;
+    const std::string& operator*() const;
+
+    size_t getIndex() const;
+    const Context& getContext() const;
+
+   private:
+    friend class StringPool;
+
+    explicit Ref(Entry* entry);
+
+    Entry* mEntry;
+  };
 
-    class Entry;
+  class StyleEntry;
 
-    class Ref {
-    public:
-        Ref();
-        Ref(const Ref&);
-        ~Ref();
+  class StyleRef {
+   public:
+    StyleRef();
+    StyleRef(const StyleRef&);
+    ~StyleRef();
 
-        Ref& operator=(const Ref& rhs);
-        const std::string* operator->() const;
-        const std::string& operator*() const;
+    StyleRef& operator=(const StyleRef& rhs);
+    const StyleEntry* operator->() const;
+    const StyleEntry& operator*() const;
 
-        size_t getIndex() const;
-        const Context& getContext() const;
-
-    private:
-        friend class StringPool;
-
-        explicit Ref(Entry* entry);
-
-        Entry* mEntry;
-    };
-
-    class StyleEntry;
-
-    class StyleRef {
-    public:
-        StyleRef();
-        StyleRef(const StyleRef&);
-        ~StyleRef();
-
-        StyleRef& operator=(const StyleRef& rhs);
-        const StyleEntry* operator->() const;
-        const StyleEntry& operator*() const;
-
-        size_t getIndex() const;
-        const Context& getContext() const;
-
-    private:
-        friend class StringPool;
-
-        explicit StyleRef(StyleEntry* entry);
-
-        StyleEntry* mEntry;
-    };
-
-    class Entry {
-    public:
-        std::string value;
-        Context context;
-        size_t index;
-
-    private:
-        friend class StringPool;
-        friend class Ref;
-
-        int ref;
-    };
-
-    struct Span {
-        Ref name;
-        uint32_t firstChar;
-        uint32_t lastChar;
-    };
-
-    class StyleEntry {
-    public:
-        Ref str;
-        std::vector<Span> spans;
-
-    private:
-        friend class StringPool;
-        friend class StyleRef;
-
-        int ref;
-    };
-
-    using const_iterator = std::vector<std::unique_ptr<Entry>>::const_iterator;
-
-    static bool flattenUtf8(BigBuffer* out, const StringPool& pool);
-    static bool flattenUtf16(BigBuffer* out, const StringPool& pool);
-
-    StringPool() = default;
-    StringPool(const StringPool&) = delete;
-
-    /**
-     * Adds a string to the pool, unless it already exists. Returns
-     * a reference to the string in the pool.
-     */
-    Ref makeRef(const StringPiece& str);
-
-    /**
-     * Adds a string to the pool, unless it already exists, with a context
-     * object that can be used when sorting the string pool. Returns
-     * a reference to the string in the pool.
-     */
-    Ref makeRef(const StringPiece& str, const Context& context);
-
-    /**
-     * Adds a style to the string pool and returns a reference to it.
-     */
-    StyleRef makeRef(const StyleString& str);
-
-    /**
-     * Adds a style to the string pool with a context object that
-     * can be used when sorting the string pool. Returns a reference
-     * to the style in the string pool.
-     */
-    StyleRef makeRef(const StyleString& str, const Context& context);
-
-    /**
-     * Adds a style from another string pool. Returns a reference to the
-     * style in the string pool.
-     */
-    StyleRef makeRef(const StyleRef& ref);
-
-    /**
-     * Moves pool into this one without coalescing strings. When this
-     * function returns, pool will be empty.
-     */
-    void merge(StringPool&& pool);
-
-    /**
-     * Retuns the number of strings in the table.
-     */
-    inline size_t size() const;
-
-    /**
-     * Reserves space for strings and styles as an optimization.
-     */
-    void hintWillAdd(size_t stringCount, size_t styleCount);
-
-    /**
-     * Sorts the strings according to some comparison function.
-     */
-    void sort(const std::function<bool(const Entry&, const Entry&)>& cmp);
-
-    /**
-     * Removes any strings that have no references.
-     */
-    void prune();
-
-private:
-    friend const_iterator begin(const StringPool& pool);
-    friend const_iterator end(const StringPool& pool);
-
-    static bool flatten(BigBuffer* out, const StringPool& pool, bool utf8);
-
-    Ref makeRefImpl(const StringPiece& str, const Context& context, bool unique);
-
-    std::vector<std::unique_ptr<Entry>> mStrings;
-    std::vector<std::unique_ptr<StyleEntry>> mStyles;
-    std::unordered_multimap<StringPiece, Entry*> mIndexedStrings;
+    size_t getIndex() const;
+    const Context& getContext() const;
+
+   private:
+    friend class StringPool;
+
+    explicit StyleRef(StyleEntry* entry);
+
+    StyleEntry* mEntry;
+  };
+
+  class Entry {
+   public:
+    std::string value;
+    Context context;
+    size_t index;
+
+   private:
+    friend class StringPool;
+    friend class Ref;
+
+    int ref;
+  };
+
+  struct Span {
+    Ref name;
+    uint32_t firstChar;
+    uint32_t lastChar;
+  };
+
+  class StyleEntry {
+   public:
+    Ref str;
+    std::vector<Span> spans;
+
+   private:
+    friend class StringPool;
+    friend class StyleRef;
+
+    int ref;
+  };
+
+  using const_iterator = std::vector<std::unique_ptr<Entry>>::const_iterator;
+
+  static bool flattenUtf8(BigBuffer* out, const StringPool& pool);
+  static bool flattenUtf16(BigBuffer* out, const StringPool& pool);
+
+  StringPool() = default;
+  StringPool(const StringPool&) = delete;
+
+  /**
+   * Adds a string to the pool, unless it already exists. Returns
+   * a reference to the string in the pool.
+   */
+  Ref makeRef(const StringPiece& str);
+
+  /**
+   * Adds a string to the pool, unless it already exists, with a context
+   * object that can be used when sorting the string pool. Returns
+   * a reference to the string in the pool.
+   */
+  Ref makeRef(const StringPiece& str, const Context& context);
+
+  /**
+   * Adds a style to the string pool and returns a reference to it.
+   */
+  StyleRef makeRef(const StyleString& str);
+
+  /**
+   * Adds a style to the string pool with a context object that
+   * can be used when sorting the string pool. Returns a reference
+   * to the style in the string pool.
+   */
+  StyleRef makeRef(const StyleString& str, const Context& context);
+
+  /**
+   * Adds a style from another string pool. Returns a reference to the
+   * style in the string pool.
+   */
+  StyleRef makeRef(const StyleRef& ref);
+
+  /**
+   * Moves pool into this one without coalescing strings. When this
+   * function returns, pool will be empty.
+   */
+  void merge(StringPool&& pool);
+
+  /**
+   * Retuns the number of strings in the table.
+   */
+  inline size_t size() const;
+
+  /**
+   * Reserves space for strings and styles as an optimization.
+   */
+  void hintWillAdd(size_t stringCount, size_t styleCount);
+
+  /**
+   * Sorts the strings according to some comparison function.
+   */
+  void sort(const std::function<bool(const Entry&, const Entry&)>& cmp);
+
+  /**
+   * Removes any strings that have no references.
+   */
+  void prune();
+
+ private:
+  friend const_iterator begin(const StringPool& pool);
+  friend const_iterator end(const StringPool& pool);
+
+  static bool flatten(BigBuffer* out, const StringPool& pool, bool utf8);
+
+  Ref makeRefImpl(const StringPiece& str, const Context& context, bool unique);
+
+  std::vector<std::unique_ptr<Entry>> mStrings;
+  std::vector<std::unique_ptr<StyleEntry>> mStyles;
+  std::unordered_multimap<StringPiece, Entry*> mIndexedStrings;
 };
 
 //
 // Inline implementation
 //
 
-inline size_t StringPool::size() const {
-    return mStrings.size();
-}
+inline size_t StringPool::size() const { return mStrings.size(); }
 
 inline StringPool::const_iterator begin(const StringPool& pool) {
-    return pool.mStrings.begin();
+  return pool.mStrings.begin();
 }
 
 inline StringPool::const_iterator end(const StringPool& pool) {
-    return pool.mStrings.end();
+  return pool.mStrings.end();
 }
 
-} // namespace aapt
+}  // namespace aapt
 
-#endif // AAPT_STRING_POOL_H
+#endif  // AAPT_STRING_POOL_H