Allocator.h

Go to the documentation of this file.

/*
 * Allocator.h
 *
 * Allows for different implementation of memory allocation methods.
 *
 * This file is part of Qualia https://github.com/sofian/qualia
 *
 * (c) 2011 Sofian Audry -- info(@)sofianaudry(.)com
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
#ifndef ALLOCATOR_H_
#define ALLOCATOR_H_

#include "common.h"

#if is_computer()
#include <new>
#endif

#include <stddef.h>
#include <stdlib.h>

class Allocator {
public:
  virtual ~Allocator() {}

  virtual void* malloc(size_t size);
  virtual void* calloc(size_t num, size_t size);
  virtual void* realloc(void* ptr, size_t size);
  virtual void free(void* ptr);
};

class Alloc {
  static Allocator* inst;

public:
  static void* malloc(size_t size);
  static void* calloc(size_t num, size_t size);
  static void* realloc(void* ptr, size_t size);
  static void free(void* ptr);
  static void init(Allocator* alloc);
  static Allocator* instance() { return inst; }
};

#define Q_NEW(T) new( Alloc::malloc(sizeof(T)) ) T

//void * operator new(size_t size, Allocator* alloc);
//#define Q_NEW(T) new( Alloc::instance() ) T
//#define _NEW new( Alloc::instance() )

//template<class T> T* _Q_ALLOC() { return Alloc::malloc(sizeof(T)); }


template<class T>
void Q_DELETE(T* obj) {
  obj->~T(); Alloc::free(obj);
}

template<class T>
T* __Q_ARRAY_NEW(size_t n) {
  size_t* ptr = (size_t*) Alloc::malloc(2*sizeof(size_t) + n * sizeof(T));
  *ptr++ = n;
  *ptr++ = sizeof(T);
  return new( ptr ) T[n];
}

#define Q_ARRAY_NEW(T,n) __Q_ARRAY_NEW<T>(n)

template<class T>
void Q_ARRAY_DELETE(T* array) {
  size_t* ptr = (size_t*) array;
  ptr-=2;
  size_t n = ptr[0];
  size_t elemSize = ptr[1];
  unsigned char* iter = (unsigned char*)array;
  while (n--) {
    ((T*)iter)->~T();
    iter += elemSize;
  }
  Alloc::free( ptr );
}

#endif /* ALLOCATOR_H_ */