clang-format runtime/vm

runtime/vm/weak_table.h

 // Copyright (c) 2013, 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_WEAK_TABLE_H_
 #define RUNTIME_VM_WEAK_TABLE_H_
 
 #include "vm/globals.h"
 
 #include "platform/assert.h"
 #include "vm/raw_object.h"
 
 namespace dart {
 
 class WeakTable {
  public:
   WeakTable() : size_(kMinSize), used_(0), count_(0) {
     ASSERT(Utils::IsPowerOfTwo(size_));
     data_ = reinterpret_cast<intptr_t*>(calloc(size_, kEntrySize * kWordSize));
   }
   explicit WeakTable(intptr_t size) : used_(0), count_(0) {
     ASSERT(size >= 0);
     ASSERT(Utils::IsPowerOfTwo(kMinSize));
     if (size < kMinSize) {
       size = kMinSize;
     }
     // Get a max size that avoids overflows.
     const intptr_t kMaxSize =
-      (kIntptrOne << (kBitsPerWord - 2)) / (kEntrySize * kWordSize);
+        (kIntptrOne << (kBitsPerWord - 2)) / (kEntrySize * kWordSize);
     ASSERT(Utils::IsPowerOfTwo(kMaxSize));
     if (size > kMaxSize) {
       size = kMaxSize;
     }
     size_ = size;
     ASSERT(Utils::IsPowerOfTwo(size_));
     data_ = reinterpret_cast<intptr_t*>(calloc(size_, kEntrySize * kWordSize));
   }
 
-  ~WeakTable() {
-    free(data_);
-  }
+  ~WeakTable() { free(data_); }
 
   static WeakTable* NewFrom(WeakTable* original) {
     return new WeakTable(SizeFor(original->count(), original->size()));
   }
 
   intptr_t size() const { return size_; }
   intptr_t used() const { return used_; }
   intptr_t count() const { return count_; }
 
   bool IsValidEntryAt(intptr_t i) const {
-    ASSERT(((ValueAt(i) == 0) &&
-            ((ObjectAt(i) == NULL) ||
-             (data_[ObjectIndex(i)] == kDeletedEntry))) ||
-           ((ValueAt(i) != 0) &&
-            (ObjectAt(i) != NULL) &&
+    ASSERT(((ValueAt(i) == 0) && ((ObjectAt(i) == NULL) ||
+                                  (data_[ObjectIndex(i)] == kDeletedEntry))) ||
+           ((ValueAt(i) != 0) && (ObjectAt(i) != NULL) &&
             (data_[ObjectIndex(i)] != kDeletedEntry)));
     return (data_[ValueIndex(i)] != 0);
   }
 
   void InvalidateAt(intptr_t i) {
     ASSERT(IsValidEntryAt(i));
     SetValueAt(i, 0);
   }
 
   RawObject* ObjectAt(intptr_t i) const {
@@ skipping 37 matching lines @@
   static const intptr_t kDeletedEntry = 1;  // Equivalent to a tagged NULL.
   static const intptr_t kMinSize = 8;
 
   static intptr_t SizeFor(intptr_t count, intptr_t size);
   static intptr_t LimitFor(intptr_t size) {
     // Maintain a maximum of 75% fill rate.
     return 3 * (size / 4);
   }
   intptr_t limit() const { return LimitFor(size()); }
 
-  intptr_t index(intptr_t i) const {
-    return i * kEntrySize;
-  }
+  intptr_t index(intptr_t i) const { return i * kEntrySize; }
 
   void set_used(intptr_t val) {
     ASSERT(val <= limit());
     used_ = val;
   }
 
   void set_count(intptr_t val) {
     ASSERT(val <= limit());
     ASSERT(val <= used());
     count_ = val;
   }
 
-  intptr_t ObjectIndex(intptr_t i) const {
-    return index(i) + kObjectOffset;
-  }
+  intptr_t ObjectIndex(intptr_t i) const { return index(i) + kObjectOffset; }
 
-  intptr_t ValueIndex(intptr_t i) const {
-    return index(i) + kValueOffset;
-  }
+  intptr_t ValueIndex(intptr_t i) const { return index(i) + kValueOffset; }
 
   void SetObjectAt(intptr_t i, RawObject* key) {
     ASSERT(i >= 0);
     ASSERT(i < size());
     data_[ObjectIndex(i)] = reinterpret_cast<intptr_t>(key);
   }
 
   void SetValueAt(intptr_t i, intptr_t val) {
     ASSERT(i >= 0);
     ASSERT(i < size());
@@ skipping 19 matching lines @@
   intptr_t size_;
   intptr_t used_;
   intptr_t count_;
 
   DISALLOW_COPY_AND_ASSIGN(WeakTable);
 };
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_WEAK_TABLE_H_