/* Copyright 2003,2004 GSMK mbH, Berlin
 * All Rights Reserved
 *
 *  $Header$
 *
 *
 *  this is an alternate Allocator implementation, which erases memory
 *  after use.
 *
 *  currently the WINCE version does not use this.
 *  see docs/stlevc.patch for how it was done for WINCE.
 *
 */

#ifndef __SAFEBYTEVECTOR_H__
// based on example from 'the c++ stl, a tutorial and reference
// by N.M.Josuttis

#include <vector>
#include <limits>

#include <string.h>	// for memset
namespace std {

// very strange, max should not be a macro in C++
// but still the compiler complains about it
#ifdef max
#undef max
#endif

template <class T>
class Safe_Allocator {
public:
    //type definitions
    typedef size_t    size_type;
    typedef ptrdiff_t difference_type;
    typedef T*        pointer;
    typedef const T*  const_pointer;
    typedef T&        reference;
    typedef const T&  const_reference;
    typedef T         value_type;

    //rebind Safe_Allocator to type U
    template <class U>
    struct rebind {
        typedef Safe_Allocator<U> other;
    };

    // added conversion from different types - needed with gcc, which converts any to <char> 
    template <class U>
    Safe_Allocator(const Safe_Allocator<U>& x) { }

    Safe_Allocator() { }


    //return address of values
    pointer address (reference value) const {
        return &value;
    }
    const_pointer address (const_reference value) const {
        return &value;
    }

    //return maximum number of elements that can be allocated
    size_type max_size () const {
        //for numeric_limits see Section 4.3, page 59
        return numeric_limits<size_t>::max() / sizeof(T);
    }

    //allocate but don't initialize num elements of type T
    pointer allocate (size_type num/*, const void* hint = 0*/) {
        //allocate memory with global new
        return (pointer) new unsigned char[num*sizeof(T)];
    }
    // with ignored 'hint' parameter
    pointer allocate (size_type num, const void*) {
        return allocate(num);
    }


    //initialize elements of allocated storage p with value value
    void construct (pointer p, const T& value) {
        //initialize memory with placement new
        new((void*)p)T(value);
    }


    //destroy elements of initialized storage p
    void destroy (pointer p) {
        // destroy objects by calling their destructor
        p->~T();
    }


    //deallocate storage p of deleted elements
    void deallocate (pointer p, size_type num) {
        if (num==0)
            return;
        // first erase the contents of the memory block
        memset((void*)p, 0xaa, num*sizeof(T));
        //deallocate memory with global delete
        operator delete((void*)p);
    }
};


//return that all specializations of this Safe_Allocator are interchangeable
template <class T1, class T2>
bool operator== (const Safe_Allocator<T1>&, const Safe_Allocator<T2>&) {
    return true;
}
template <class T1, class T2>
bool operator!= (const Safe_Allocator<T1>&, const Safe_Allocator<T2>&) {
    return false;
}

template<>
class Safe_Allocator<void> {
public:
    typedef void* pointer;
};

}


#define __SAFEBYTEVECTOR_H__
#endif