wiselib.testing/util/allocators/new_delete_allocator.h

Go to the documentation of this file.

#ifndef __WISELIB_UTIL_ALLOCATORS_NEW_DELETE_ALLOCATOR_H
#define __WISELIB_UTIL_ALLOCATORS_NEW_DELETE_ALLOCATOR_H

#define KEEP_STATS 1

namespace wiselib {

template<
   typename OsModel_P
>
class NewDeleteAllocator {
   public:
      typedef OsModel_P OsModel;
      typedef NewDeleteAllocator<OsModel_P> self_type;
      typedef self_type* self_pointer_t;
      
      enum { SUCCESS = OsModel::SUCCESS, ERR_UNSPEC = OsModel::ERR_UNSPEC };
      
      template<typename T>
      struct Ref {
         // The following struct is mostly equivalent to the typedef but
         // allows auto-initialization to 0
         struct pointer_t {
            pointer_t() : p_(0) { }
            pointer_t(T* p) : p_(p) { }
            pointer_t(const pointer_t& other) : p_(other.p_) { }
            T& operator*() const { return *p_; }
            T* operator->() const { return p_; }
            T& operator[](size_t idx) { return p_[idx]; }
            const T& operator[](size_t idx) const { return p_[idx]; }
            bool operator==(const pointer_t& other) const { return p_ == other.p_; }
            bool operator!=(const pointer_t& other) const { return p_ != other.p_; }
            operator bool() const { return p_ != 0; }
            pointer_t& operator++() { ++p_; return *this; }
            pointer_t& operator--() { --p_; return *this; }
            T* raw() { return p_; }
            T* p_;
         };
      };
      
      NewDeleteAllocator()
         #if KEEP_STATS
            : allocated_(0), news_(0), deletes_(0)
         #endif
      {
      }
      
      template<typename T>
      typename Ref<T>::pointer_t allocate() {
         #if KEEP_STATS
            allocated_ += sizeof(T);
            news_++;
         #endif
         typename Ref<T>::pointer_t r = new T;
         return r;
      }
      
      template<typename T>
      typename Ref<T>::pointer_t allocate_array(typename OsModel::size_t n) {
         #if KEEP_STATS
            allocated_ += sizeof(T[n]);
            news_++;
         #endif
         return new T[n];
      }
      
      template<typename T>
      int free(typename Ref<T>::pointer_t p) {
         #if KEEP_STATS
            allocated_ -= sizeof(T);
            deletes_++;
         #endif
         delete p.p_;
         return SUCCESS;
      }
      
      template<typename T>
      int free_array(typename Ref<T>::pointer_t p) {
         #if KEEP_STATS
            allocated_ -= sizeof(*p.p_);
            deletes_++;
         #endif
         delete[] p.p_;
         return SUCCESS;
      }
      
      template<typename Debug_P>
      void print_stats(Debug_P* d) {
         #if KEEP_STATS
         d->debug("\nnew/delete allocator statistics\n");
         d->debug("-------------------------------\n");
         // theres currently no way to know the size of an array by its
         // pointer so a correct allocated_ counting would be more involved
         //d->debug("allocated bytes: %14lu\n", allocated_);
         d->debug("allocations    : %14lu\n", news_);
         d->debug("frees          : %14lu\n", deletes_);
         d->debug("\n");
         #endif
      }
   
   private:
      #if KEEP_STATS
      unsigned long allocated_, news_, deletes_;
      #endif
};

  
} // namespace wiselib

#endif // NEW_DELETE_ALLOCATOR_H