// Copyright 2018 The Fuchsia 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 SRC_UI_LIB_ESCHER_UTIL_STACK_ALLOCATOR_H_
#define SRC_UI_LIB_ESCHER_UTIL_STACK_ALLOCATOR_H_

#include <algorithm>
#include <type_traits>

#include "src/ui/lib/escher/util/align.h"

namespace escher {

// A simple, fast allocator that allocates from a fixed-size region within
// itself.  It can return either pointers to uninitialized memory, or memory
// filled with a specified value.  Resetting the allocator for reuse is
// extremely fast: the amount of used memory is simply set to zero.  No
// destructors are called when the allocator is reset/destroyed; for safety,
// only trivially-destructible types can be allocated.
template <typename T, size_t N>
class StackAllocator {
 public:
  StackAllocator() : base_(NextAlignedPtr<T>(&buffer_[0])) {}

  // Return a pointer to the specified number of T objects.  Return nullptr if
  // the requested number is zero, or if there is not enough space available.
  // The contents of the pointed-to memory are undefined.
  T* Allocate(size_t count = 1) {
    if (count == 0)
      return nullptr;

    size_t to_be_used = used_ + count;
    if (to_be_used > N)
      return nullptr;

    T* ptr = base_ + used_;
    used_ = to_be_used;
    return ptr;
  }

  // Return a pointer to the specified number of T objects.  Return nullptr if
  // the requested number is zero, or if there is not enough space available.
  // Each T item in the pointed-to memory is initialized to the specified value,
  // or a default value if none is specified.
  T* AllocateFilled(size_t count = 1, const T& fill_value = T()) {
    T* ptr = Allocate(count);
    if (ptr) {
      std::fill(ptr, ptr + count, fill_value);
    }
    return ptr;
  }

  // Reset the allocator so that its memory can be reallocated.  Any pointers
  // previously obtained from Allocate() and AllocateFilled() are now invalid,
  // and should not be used.
  void Reset() { used_ = 0; }

 private:
  static_assert(std::is_trivially_destructible<T>::value, "T is not trivially destructable");

  size_t used_ = 0;

  // |buffer_| is not necessarily aligned to alignof(T), so we initialize
  // |base_| to point to the first properly-aligned address within |buffer_|.
  // Adding "alignof(T)" to the size of |buffer_| guarantees that "base_[N-1]"
  // fits within it.
  T* base_;
  uint8_t buffer_[N * sizeof(T) + alignof(T)];
};

}  // namespace escher

#endif  // SRC_UI_LIB_ESCHER_UTIL_STACK_ALLOCATOR_H_