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

runtime/platform/hashmap.cc

 // Copyright (c) 2012, 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.
 
 #include "platform/hashmap.h"
 
 #include "platform/utils.h"
 
 namespace dart {
 
 HashMap::HashMap(MatchFun match, uint32_t initial_capacity) {
   match_ = match;
   Initialize(initial_capacity);
 }
 
-
 HashMap::~HashMap() {
   delete[] map_;
 }
 
-
 HashMap::Entry* HashMap::Lookup(void* key, uint32_t hash, bool insert) {
   // Find a matching entry.
   Entry* p = Probe(key, hash);
   if (p->key != NULL) {
     return p;
   }
 
   // No entry found; insert one if necessary.
   if (insert) {
     p->key = key;
     p->value = NULL;
     p->hash = hash;
     occupancy_++;
 
     // Grow the map if we reached >= 80% occupancy.
     if ((occupancy_ + (occupancy_ / 4)) >= capacity_) {
       Resize();
       p = Probe(key, hash);
     }
 
     return p;
   }
 
   // No entry found and none inserted.
   return NULL;
 }
 
-
 void HashMap::Remove(void* key, uint32_t hash) {
   // Lookup the entry for the key to remove.
   Entry* candidate = Probe(key, hash);
   if (candidate->key == NULL) {
     // Key not found nothing to remove.
     return;
   }
 
   // To remove an entry we need to ensure that it does not create an empty
   // entry that will cause the search for another entry to stop too soon. If all
@@ skipping 42 matching lines @@
       *candidate = *next;
       candidate = next;
     }
   }
 
   // Clear the candidate which will not break searching the hash table.
   candidate->key = NULL;
   occupancy_--;
 }
 
-
 void HashMap::Clear(ClearFun clear) {
   // Mark all entries as empty.
   const Entry* end = map_end();
   for (Entry* p = map_; p < end; p++) {
     if ((clear != NULL) && (p->key != NULL)) {
       clear(p->value);
     }
     p->key = NULL;
   }
   occupancy_ = 0;
 }
 
-
 HashMap::Entry* HashMap::Start() const {
   return Next(map_ - 1);
 }
 
-
 HashMap::Entry* HashMap::Next(Entry* p) const {
   const Entry* end = map_end();
   ASSERT(map_ - 1 <= p && p < end);
   for (p++; p < end; p++) {
     if (p->key != NULL) {
       return p;
     }
   }
   return NULL;
 }
 
-
 HashMap::Entry* HashMap::Probe(void* key, uint32_t hash) {
   ASSERT(key != NULL);
 
   ASSERT(dart::Utils::IsPowerOfTwo(capacity_));
   Entry* p = map_ + (hash & (capacity_ - 1));
   const Entry* end = map_end();
   ASSERT(map_ <= p && p < end);
 
   ASSERT(occupancy_ < capacity_);  // Guarantees loop termination.
   while (p->key != NULL && (hash != p->hash || !match_(key, p->key))) {
     p++;
     if (p >= end) {
       p = map_;
     }
   }
 
   return p;
 }
 
-
 void HashMap::Initialize(uint32_t capacity) {
   ASSERT(dart::Utils::IsPowerOfTwo(capacity));
   map_ = new Entry[capacity];
   if (map_ == NULL) {
     OUT_OF_MEMORY();
   }
   capacity_ = capacity;
   occupancy_ = 0;
 }
 
-
 void HashMap::Resize() {
   Entry* map = map_;
   uint32_t n = occupancy_;
 
   // Allocate larger map.
   Initialize(capacity_ * 2);
 
   // Rehash all current entries.
   for (Entry* p = map; n > 0; p++) {
     if (p->key != NULL) {
       Lookup(p->key, p->hash, true)->value = p->value;
       n--;
     }
   }
 
   // Delete old map.
   delete[] map;
 }
 
 }  // namespace dart