[Courgette] AssemblyProgram: Serialize data to single raw buffer, instead of storing pointer of obj…

courgette/memory_allocator.h

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef COURGETTE_MEMORY_ALLOCATOR_H_
 #define COURGETTE_MEMORY_ALLOCATOR_H_
 
-#include <stddef.h>
-#include <stdint.h>
-#include <stdlib.h>
+#include <cstddef>
+#include <cstdint>
+#include <cstdlib>
 
 #include "base/compiler_specific.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/process/memory.h"
 
 #ifndef NDEBUG
 
 // A helper class to track down call sites that are not handling error cases.
@@ skipping 303 matching lines @@
 #endif  // OS_WIN
 
 // Manages a growable buffer.  The buffer allocation is done by the
 // MemoryAllocator class.  This class will not throw exceptions so call sites
 // must be prepared to handle memory allocation failures.
 // The interface is STL inspired to avoid having to make too many changes
 // to code that previously was using STL.
 template<typename T, class Allocator = MemoryAllocator<T> >
 class NoThrowBuffer {
  public:
-  typedef T value_type;
+  using value_type = T;
+  using iterator = T*;
+  using const_iterator = const T*;
+
   static const size_t kAllocationFailure = 0xffffffff;
   static const size_t kStartSize = sizeof(T) > 0x100 ? 1 : 0x100 / sizeof(T);
 
   NoThrowBuffer() : buffer_(NULL), size_(0), alloc_size_(0) {
   }
 
   ~NoThrowBuffer() {
     clear();
   }
 
@@ skipping 91 matching lines @@
   }
 
   const T& back() const {
     return buffer_[size_ - 1];
   }
 
   T& back() {
     return buffer_[size_ - 1];
   }
 
-  const T* begin() const {
+  const_iterator begin() const {
     if (!size_)
       return NULL;
     return buffer_;
   }
 
-  T* begin() {
+  iterator begin() {
     if (!size_)
       return NULL;
     return buffer_;
   }
 
-  const T* end() const {
+  const_iterator end() const {
     if (!size_)
       return NULL;
     return buffer_ + size_;
   }
 
-  T* end() {
+  iterator end() {
     if (!size_)
       return NULL;
     return buffer_ + size_;
   }
 
   const T& operator[](size_t index) const {
     DCHECK(index < size_);
     return buffer_[index];
   }
 
@@ skipping 22 matching lines @@
  protected:
   T* buffer_;
   size_t size_;  // how much of the buffer we're using.
   size_t alloc_size_;  // how much space we have allocated.
   Allocator alloc_;
 };
 
 }  // namespace courgette
 
 #endif  // COURGETTE_MEMORY_ALLOCATOR_H_