Stacker.h

 
#ifndef MFRAME_C045F3C4_B727_4170_9124_44EFD0DADB46
#define MFRAME_C045F3C4_B727_4170_9124_44EFD0DADB46
 
/* ***************************************************************************************
 * Include
 */
 
//----------------------------------------------------------------------------------------
#include "./../lang/Memory.h"
#include "./../sys/Allocator.h"
#include "./../util/Collection.h"
#include "./../util/Iterator.h"
 
//----------------------------------------------------------------------------------------
 
/* ***************************************************************************************
 * Namespace
 */
namespace ufm::sys {
  class Stacker;
}  // namespace ufm::sys
 
/* ***************************************************************************************
 * Class/Interface/Struct
 */
 
class ufm::sys::Stacker : public ufm::lang::Object,
                          public ufm::util::Collection<void*>,
                          public ufm::sys::Allocator {
  /* *************************************************************************************
   * Variable
   */
 protected:
  ufm::lang::Memory vMemory;  
  uint8* vStackPointer;
 
  uint32 vMask;
 
  /* *************************************************************************************
   * Abstract Method
   */
 
  /* *************************************************************************************
   * Construct Method
   */
 public:
  template <size_t N>
  inline Stacker(uint64 (&buffer)[N])
      : Stacker(ufm::lang::Memory(buffer, (N * sizeof(uint64)))) {
    return;
  }
 
  inline Stacker(void* buffer, int size) : Stacker(ufm::lang::Memory(buffer, size)) {
    return;
  }
 
  Stacker(ufm::lang::Memory memory) noexcept;
 
  virtual ~Stacker(void) override;
 
  /* *************************************************************************************
   * Operator Method
   */
 
  /* *************************************************************************************
   * Override Method - ufm::lang::Iterable<const void*>
   */
 public:
  virtual void forEach(ufm::func::Consumer<void*&>& action) override;
 
  virtual void** elementAt(int index) const override;
 
  virtual int nextIndex(int index) const override;
 
  virtual ufm::util::Iterator<void*> begin(void) override;
 
  virtual ufm::util::Iterator<void*> end(void) override;
 
  /* *************************************************************************************
   * Override Method - ufm::util::Collection<ufm::lang::Memory>
   */
 public:
  virtual void clear(void) override;
 
  virtual bool isEmpty(void) const override;
 
  virtual int size(void) const override;
 
  /* *************************************************************************************
   * Override Method - ufm::sys::Allocator
   */
 public:
  virtual void* alloc(int size) override;
 
  virtual bool free(void* ptr, int size = 0) override;
 
  virtual int getFree(void) override;
 
  virtual int getTotal(void) override;
 
  /* *************************************************************************************
   * Public Method
   */
 public:
  virtual ufm::lang::Memory allocMemory(int size);
 
  /* *************************************************************************************
   * Protected Method
   */
 
  /* *************************************************************************************
   * Private Method
   */
 
  /* *************************************************************************************
   * Static Variable
   */
 
  /* *************************************************************************************
   * Static Method
   */
 public:
  template <size_t N>
  static inline Stacker* construct(uint64 (&buffer)[N]) {
    return construct(static_cast<void*>(buffer), static_cast<int>(sizeof(uint64)) * N);
  }
 
  static Stacker* construct(void* pointer, int size);
};
 
/* ***************************************************************************************
 * End of file
 */
 
#endif /* MFRAME_C045F3C4_B727_4170_9124_44EFD0DADB46 */