clang-format runtime/vm

runtime/vm/store_buffer.h

 // 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.
 
 #ifndef RUNTIME_VM_STORE_BUFFER_H_
 #define RUNTIME_VM_STORE_BUFFER_H_
 
 #include "platform/assert.h"
 #include "vm/globals.h"
 
 namespace dart {
 
 // Forward declarations.
 class Isolate;
 class Mutex;
 class RawObject;
 
 // A set of RawObject*. Must be emptied before destruction (using Pop/Reset).
-template<int Size>
+template <int Size>
 class PointerBlock {
  public:
   enum { kSize = Size };
 
   void Reset() {
     top_ = 0;
     next_ = NULL;
   }
 
   PointerBlock<Size>* next() const { return next_; }
@@ skipping 31 matching lines @@
  private:
   PointerBlock() : next_(NULL), top_(0) {}
   ~PointerBlock() {
     ASSERT(IsEmpty());  // Guard against unintentionally discarding pointers.
   }
 
   PointerBlock<Size>* next_;
   int32_t top_;
   RawObject* pointers_[kSize];
 
-  template<int> friend class BlockStack;
+  template <int>
+  friend class BlockStack;
 
   DISALLOW_COPY_AND_ASSIGN(PointerBlock);
 };
 
 
 // A synchronized collection of pointer blocks of a particular size.
 // This class is meant to be used as a base (note PushBlockImpl is protected).
 // The global list of cached empty blocks is currently per-size.
-template<int BlockSize>
+template <int BlockSize>
 class BlockStack {
  public:
   typedef PointerBlock<BlockSize> Block;
 
   BlockStack();
   ~BlockStack();
   static void InitOnce();
   static void ShutDown();
 
   // Partially filled blocks can be reused, and there is an "inifite" supply
@@ skipping 14 matching lines @@
  protected:
   class List {
    public:
     List() : head_(NULL), length_(0) {}
     ~List();
     void Push(Block* block);
     Block* Pop();
     intptr_t length() const { return length_; }
     bool IsEmpty() const { return head_ == NULL; }
     Block* PopAll();
+
    private:
     Block* head_;
     intptr_t length_;
     DISALLOW_COPY_AND_ASSIGN(List);
   };
 
   // Adds and transfers ownership of the block to the buffer.
   void PushBlockImpl(Block* block);
 
   // If needed, trims the global cache of empty blocks.
@@ skipping 12 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(BlockStack);
 };
 
 
 static const int kStoreBufferBlockSize = 1024;
 class StoreBuffer : public BlockStack<kStoreBufferBlockSize> {
  public:
   // Interrupt when crossing this threshold of non-empty blocks in the buffer.
   static const intptr_t kMaxNonEmpty = 100;
 
-  enum ThresholdPolicy {
-    kCheckThreshold,
-    kIgnoreThreshold
-  };
+  enum ThresholdPolicy { kCheckThreshold, kIgnoreThreshold };
 
   // Adds and transfers ownership of the block to the buffer. Optionally
   // checks the number of non-empty blocks for overflow, and schedules an
   // interrupt on the current isolate if so.
   void PushBlock(Block* block, ThresholdPolicy policy);
 
   // Check whether non-empty blocks have exceeded kMaxNonEmpty (but takes no
   // action).
   bool Overflowed();
 };
 
 
 typedef StoreBuffer::Block StoreBufferBlock;
 
 
 static const int kMarkingStackBlockSize = 64;
 class MarkingStack : public BlockStack<kMarkingStackBlockSize> {
  public:
   // Adds and transfers ownership of the block to the buffer.
   void PushBlock(Block* block) {
     BlockStack<Block::kSize>::PushBlockImpl(block);
   }
 };
 
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_STORE_BUFFER_H_