VM: Re-format to use at most one newline between functions

runtime/vm/hash_table.h

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef RUNTIME_VM_HASH_TABLE_H_
 #define RUNTIME_VM_HASH_TABLE_H_
 
 #include "platform/assert.h"
 #include "vm/object.h"
 
@@ skipping 37 matching lines @@
 //
 // If you *know* that no mutating operations were called, you can optimize:
 //  ...
 //  obj ^= cache.GetOrNull(name);
 //  ASSERT(cache.Release().raw() == get_foo_cache());
 //
 // TODO(koda): When exposing these to Dart code, document and assert that
 // KeyTraits methods must not run Dart code (since the C++ code doesn't check
 // for concurrent modification).
 
-
 // Open-addressing hash table template using a RawArray as backing storage.
 //
 // The elements of the array are partitioned into entries:
 //  [ header | metadata | entry0 | entry1 | ... | entryN ]
 // Each entry contains a key, followed by zero or more payload components,
 // and has 3 possible states: unused, occupied, or deleted.
 // The header tracks the number of entries in each state.
 // Any object except Object::sentinel() and Object::transition_sentinel()
 // may be stored as a key. Any object may be stored in a payload.
 //
@@ skipping 307 matching lines @@
 
   Object* key_handle_;
   Smi* smi_handle_;
   // Exactly one of these is non-NULL, depending on whether Release was called.
   Array* data_;
   Array* released_data_;
 
   friend class HashTables;
 };
 
-
 // Table with unspecified iteration order. No payload overhead or metadata.
 template <typename KeyTraits, intptr_t kUserPayloadSize>
 class UnorderedHashTable : public HashTable<KeyTraits, kUserPayloadSize, 0> {
  public:
   typedef HashTable<KeyTraits, kUserPayloadSize, 0> BaseTable;
   static const intptr_t kPayloadSize = kUserPayloadSize;
   explicit UnorderedHashTable(RawArray* data)
       : BaseTable(Thread::Current()->zone(), data) {}
   UnorderedHashTable(Zone* zone, RawArray* data) : BaseTable(zone, data) {}
   UnorderedHashTable(Object* key, Smi* value, Array* data)
@@ skipping 15 matching lines @@
     intptr_t Current() { return entry_; }
 
    private:
     const UnorderedHashTable* table_;
     intptr_t entry_;
   };
 
   // No extra book-keeping needed for Initialize, InsertKey, DeleteEntry.
 };
 
-
 class HashTables : public AllStatic {
  public:
   // Allocates and initializes a table.
   template <typename Table>
   static RawArray* New(intptr_t initial_capacity,
                        Heap::Space space = Heap::kNew) {
     Table table(
         Thread::Current()->zone(),
         Array::New(Table::ArrayLengthForNumOccupied(initial_capacity), space));
     table.Initialize();
@@ skipping 63 matching lines @@
         for (intptr_t i = 0; i < Table::kPayloadSize; ++i) {
           obj = table.GetPayload(entry, i);
           result.SetAt(result_index++, obj);
         }
       }
     }
     return result.raw();
   }
 };
 
-
 template <typename BaseIterTable>
 class HashMap : public BaseIterTable {
  public:
   explicit HashMap(RawArray* data)
       : BaseIterTable(Thread::Current()->zone(), data) {}
   HashMap(Zone* zone, RawArray* data) : BaseIterTable(zone, data) {}
   HashMap(Object* key, Smi* value, Array* data)
       : BaseIterTable(key, value, data) {}
   template <typename Key>
   RawObject* GetOrNull(const Key& key, bool* present = NULL) const {
@@ skipping 65 matching lines @@
   void Clear() const { BaseIterTable::Initialize(); }
 
  protected:
   void EnsureCapacity() const {
     static const double kMaxLoadFactor = 0.75;
     // We currently never shrink.
     HashTables::EnsureLoadFactor(0.0, kMaxLoadFactor, *this);
   }
 };
 
-
 template <typename KeyTraits>
 class UnorderedHashMap : public HashMap<UnorderedHashTable<KeyTraits, 1> > {
  public:
   typedef HashMap<UnorderedHashTable<KeyTraits, 1> > BaseMap;
   explicit UnorderedHashMap(RawArray* data)
       : BaseMap(Thread::Current()->zone(), data) {}
   UnorderedHashMap(Zone* zone, RawArray* data) : BaseMap(zone, data) {}
   UnorderedHashMap(Object* key, Smi* value, Array* data)
       : BaseMap(key, value, data) {}
 };
 
-
 template <typename BaseIterTable>
 class HashSet : public BaseIterTable {
  public:
   explicit HashSet(RawArray* data)
       : BaseIterTable(Thread::Current()->zone(), data) {}
   HashSet(Zone* zone, RawArray* data) : BaseIterTable(zone, data) {}
   HashSet(Object* key, Smi* value, Array* data)
       : BaseIterTable(key, value, data) {}
   bool Insert(const Object& key) {
     EnsureCapacity();
@@ skipping 56 matching lines @@
   void Clear() const { BaseIterTable::Initialize(); }
 
  protected:
   void EnsureCapacity() const {
     static const double kMaxLoadFactor = 0.75;
     // We currently never shrink.
     HashTables::EnsureLoadFactor(0.0, kMaxLoadFactor, *this);
   }
 };
 
-
 template <typename KeyTraits>
 class UnorderedHashSet : public HashSet<UnorderedHashTable<KeyTraits, 0> > {
  public:
   typedef HashSet<UnorderedHashTable<KeyTraits, 0> > BaseSet;
   explicit UnorderedHashSet(RawArray* data)
       : BaseSet(Thread::Current()->zone(), data) {
     ASSERT(data != Array::null());
   }
   UnorderedHashSet(Zone* zone, RawArray* data) : BaseSet(zone, data) {}
   UnorderedHashSet(Object* key, Smi* value, Array* data)
       : BaseSet(key, value, data) {}
 };
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_HASH_TABLE_H_