/*
 *
 * Copyright (c) 1994
 * Hewlett-Packard Company
 *
 */


#ifndef MEMORY_HANDLER_H
#define MEMORY_HANDLER_H

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

inline void errorFunction(char* s) { printf(s); exit(1); }

inline void* operator new(size_t, void* p) {return p;} 

inline void* memalloc(size_t size)
{
    void* tmp = ::operator new (size);
    if (tmp == 0) errorFunction("out of memory\n");
    return tmp;
}

template <class T>
class Allocator
{
public:
    Allocator() {}
    int operator==(Allocator<T>&) { return 1; }
    int operator!=(Allocator<T>&) { return 0; }
    T* operator()(size_t n)
    {
	T* tmp = new T[n];
	if (tmp == 0) errorFunction("out of memory\n");
	return tmp;
    }
};

template <class T>
class ExplicitDestructor
{
public:
    ExplicitDestructor() {}
    int operator==(ExplicitDestructor<T>&) { return 1; }
    int operator!=(ExplicitDestructor<T>&) { return 0; }
    void operator()(T& /* x */)
    {
//	(&x)->T::~T();
    }
};

template <class T>
class PointerToRawStorage
{
protected:
    T* p;
public:
    PointerToRawStorage(T* x) : p(x) {}
    PointerToRawStorage<T>& operator*() { return *this; }
    PointerToRawStorage<T>& operator=(T& element)
    {
	new (p++) T(element);
	return *this;
    }        
    PointerToRawStorage<T>& operator++()
    {
	p++;
	return *this;
    }
    PointerToRawStorage<T> operator++(int)
    {
	PointerToRawStorage<T> tmp = *this;
	p++;
	return tmp;
    }
    PointerToRawStorage<T>& operator--()
    {
	p--;
	return *this;
    }
    PointerToRawStorage<T> operator--(int)
    {
	PointerToRawStorage<T> tmp = *this;
	p--;
	return tmp;
    }
    int operator==(PointerToRawStorage<T>& x) const
    {
	return p == x.p;
    }
    int operator!=(PointerToRawStorage<T>& x) const
    {
	return !(*this == x);
    }
};

#endif