clang-format runtime/vm

runtime/vm/clustered_snapshot.h

 // Copyright (c) 2016, 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_CLUSTERED_SNAPSHOT_H_
 #define RUNTIME_VM_CLUSTERED_SNAPSHOT_H_
 
 #include "platform/assert.h"
 #include "vm/allocation.h"
 #include "vm/bitfield.h"
@@ skipping 28 matching lines @@
 // is then read for each cluster, filling the reference array. Then the
 // initialization/fill secton is read for each cluster, using the indices into
 // the reference array to fill pointers. At this point, every object has been
 // touched exactly once and in order, making this approach very cache friendly.
 // Finally, each cluster is given an opportunity to perform some fix-ups that
 // require the graph has been fully loaded, such as rehashing, though most
 // clusters do not require fixups.
 
 class SerializationCluster : public ZoneAllocated {
  public:
-  virtual ~SerializationCluster() { }
+  virtual ~SerializationCluster() {}
 
   // Add [object] to the cluster and push its outgoing references.
   virtual void Trace(Serializer* serializer, RawObject* object) = 0;
 
   // Write the cluster type and information needed to allocate the cluster's
   // objects. For fixed sized objects, this is just the object count. For
   // variable sized objects, this is the object count and length of each object.
   virtual void WriteAlloc(Serializer* serializer) = 0;
 
   // Write the byte and reference data of the cluster's objects.
   virtual void WriteFill(Serializer* serializer) = 0;
 };
 
 
 class DeserializationCluster : public ZoneAllocated {
  public:
-  DeserializationCluster() : start_index_(-1), stop_index_(-1) { }
-  virtual ~DeserializationCluster() { }
+  DeserializationCluster() : start_index_(-1), stop_index_(-1) {}
+  virtual ~DeserializationCluster() {}
 
   // Allocate memory for all objects in the cluster and write their addresses
   // into the ref array. Do not touch this memory.
   virtual void ReadAlloc(Deserializer* deserializer) = 0;
 
   // Initialize the cluster's objects. Do not touch the memory of other objects.
   virtual void ReadFill(Deserializer* deserializer) = 0;
 
   // Complete any action that requires the full graph to be deserialized, such
   // as rehashing.
-  virtual void PostLoad(const Array& refs, Snapshot::Kind kind, Zone* zone) { }
+  virtual void PostLoad(const Array& refs, Snapshot::Kind kind, Zone* zone) {}
 
  protected:
   // The range of the ref array that belongs to this cluster.
   intptr_t start_index_;
   intptr_t stop_index_;
 };
 
 
 class SmiObjectIdPair {
  public:
-  SmiObjectIdPair() : smi_(NULL), id_(0) { }
+  SmiObjectIdPair() : smi_(NULL), id_(0) {}
   RawSmi* smi_;
   intptr_t id_;
 
   bool operator==(const SmiObjectIdPair& other) const {
     return (smi_ == other.smi_) && (id_ == other.id_);
   }
 };
 
 
 class SmiObjectIdPairTrait {
@@ skipping 79 matching lines @@
 
     intptr_t id = heap_->GetObjectId(object);
     if (id == 0) {
       heap_->SetObjectId(object, 1);
       ASSERT(heap_->GetObjectId(object) != 0);
       stack_.Add(object);
       num_written_objects_++;
     }
   }
 
-  void AddUntracedRef() {
-    num_written_objects_++;
-  }
+  void AddUntracedRef() { num_written_objects_++; }
 
   void Trace(RawObject* object);
 
   SerializationCluster* NewClusterForClass(intptr_t cid);
 
   void ReserveHeader() {
     // Make room for recording snapshot buffer size.
     stream_.set_current(stream_.buffer() + Snapshot::kHeaderSize);
   }
 
@@ skipping 105 matching lines @@
                                bool is_vm_isolate,
                                bool is_canonical = false);
 
   // Reads raw data (for basic types).
   // sizeof(T) must be in {1,2,4,8}.
   template <typename T>
   T Read() {
     return ReadStream::Raw<sizeof(T), T>::Read(&stream_);
   }
 
-  void ReadBytes(uint8_t* addr, intptr_t len) {
-    stream_.ReadBytes(addr, len);
-  }
+  void ReadBytes(uint8_t* addr, intptr_t len) { stream_.ReadBytes(addr, len); }
 
   const uint8_t* CurrentBufferAddress() const {
     return stream_.AddressOfCurrentPosition();
   }
 
-  void Advance(intptr_t value) {
-    stream_.Advance(value);
-  }
+  void Advance(intptr_t value) { stream_.Advance(value); }
 
-  intptr_t PendingBytes() const {
-    return stream_.PendingBytes();
-  }
+  intptr_t PendingBytes() const { return stream_.PendingBytes(); }
 
-  void AddBaseObject(RawObject* base_object) {
-    AssignRef(base_object);
-  }
+  void AddBaseObject(RawObject* base_object) { AssignRef(base_object); }
 
   void AssignRef(RawObject* object) {
     ASSERT(next_ref_index_ <= num_objects_);
     refs_->ptr()->data()[next_ref_index_] = object;
     next_ref_index_++;
   }
 
   RawObject* Ref(intptr_t index) const {
     ASSERT(index > 0);
     ASSERT(index <= num_objects_);
@@ skipping 54 matching lines @@
                      uint8_t** vm_isolate_snapshot_buffer,
                      uint8_t** isolate_snapshot_buffer,
                      ReAlloc alloc,
                      InstructionsWriter* instructions_writer);
   ~FullSnapshotWriter();
 
   uint8_t** vm_isolate_snapshot_buffer() const {
     return vm_isolate_snapshot_buffer_;
   }
 
-  uint8_t** isolate_snapshot_buffer() const {
-    return isolate_snapshot_buffer_;
-  }
+  uint8_t** isolate_snapshot_buffer() const { return isolate_snapshot_buffer_; }
 
   Thread* thread() const { return thread_; }
   Zone* zone() const { return thread_->zone(); }
   Isolate* isolate() const { return thread_->isolate(); }
   Heap* heap() const { return isolate()->heap(); }
 
   // Writes a full snapshot of the Isolate.
   void WriteFullSnapshot();
 
-  intptr_t VmIsolateSnapshotSize() const {
-    return vm_isolate_snapshot_size_;
-  }
-  intptr_t IsolateSnapshotSize() const {
-    return isolate_snapshot_size_;
-  }
+  intptr_t VmIsolateSnapshotSize() const { return vm_isolate_snapshot_size_; }
+  intptr_t IsolateSnapshotSize() const { return isolate_snapshot_size_; }
 
  private:
   // Writes a snapshot of the VM Isolate.
   intptr_t WriteVmIsolateSnapshot();
 
   // Writes a full snapshot of a regular Dart Isolate.
   void WriteIsolateFullSnapshot(intptr_t num_base_objects);
 
   Thread* thread_;
   Snapshot::Kind kind_;
@@ skipping 12 matching lines @@
 };
 
 
 class VmIsolateSnapshotReader {
  public:
   VmIsolateSnapshotReader(Snapshot::Kind kind,
                           const uint8_t* buffer,
                           intptr_t size,
                           const uint8_t* instructions_buffer,
                           const uint8_t* data_buffer,
-                          Thread* thread) :
-      kind_(kind),
-      thread_(thread),
-      buffer_(buffer),
-      size_(size),
-      instructions_buffer_(instructions_buffer),
-      data_buffer_(data_buffer) {
+                          Thread* thread)
+      : kind_(kind),
+        thread_(thread),
+        buffer_(buffer),
+        size_(size),
+        instructions_buffer_(instructions_buffer),
+        data_buffer_(data_buffer) {
     thread->isolate()->set_compilation_allowed(kind != Snapshot::kAppNoJIT);
   }
 
-  ~VmIsolateSnapshotReader() { }
+  ~VmIsolateSnapshotReader() {}
 
   RawApiError* ReadVmIsolateSnapshot();
 
  private:
   Snapshot::Kind kind_;
   Thread* thread_;
   const uint8_t* buffer_;
   intptr_t size_;
   const uint8_t* instructions_buffer_;
   const uint8_t* data_buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(VmIsolateSnapshotReader);
 };
 
 
 class IsolateSnapshotReader {
  public:
   IsolateSnapshotReader(Snapshot::Kind kind,
                         const uint8_t* buffer,
                         intptr_t size,
                         const uint8_t* instructions_buffer,
                         const uint8_t* data_buffer,
-                        Thread* thread) :
-      kind_(kind),
-      thread_(thread),
-      buffer_(buffer),
-      size_(size),
-      instructions_buffer_(instructions_buffer),
-      data_buffer_(data_buffer) {
+                        Thread* thread)
+      : kind_(kind),
+        thread_(thread),
+        buffer_(buffer),
+        size_(size),
+        instructions_buffer_(instructions_buffer),
+        data_buffer_(data_buffer) {
     thread->isolate()->set_compilation_allowed(kind != Snapshot::kAppNoJIT);
   }
 
   ~IsolateSnapshotReader() {}
 
   RawApiError* ReadFullSnapshot();
 
  private:
   Snapshot::Kind kind_;
   Thread* thread_;
   const uint8_t* buffer_;
   intptr_t size_;
   const uint8_t* instructions_buffer_;
   const uint8_t* data_buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(IsolateSnapshotReader);
 };
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_CLUSTERED_SNAPSHOT_H_