## NAME

ACE_Allocator_Adapter - This class is an Adapter that allows the `ACE_Allocator` to use the `Malloc` class below.

## SYNOPSIS

    #include <ace/Malloc_T.h>

    template<class MALLOC>
    class ACE_Allocator_Adapter : public ACE_Allocator
    {
      public:
        typedef MALLOC ALLOCATOR;
            typedef const ACE_TYPENAME MALLOC::MEMORY_POOL_OPTIONS *MEMORY_POOL_OPTIONS;

        typedef const void *MEMORY_POOL_OPTIONS;
        ACE_Allocator_Adapter (LPCTSTR pool_name = 0);
        inline ACE_Allocator_Adapter (
            LPCTSTR pool_name,
            LPCTSTR lock_name,
            MEMORY_POOL_OPTIONS options = 0
            );
        virtual ~ACE_Allocator_Adapter (void);
        virtual void *malloc (size_t nbytes);
        virtual void *calloc (size_t nbytes, char initial_value = '  ');
        virtual void free (void *ptr);
        virtual int remove (void);
        virtual int bind (
            const char *name,
            void *pointer,
            int duplicates = 0
            );
        virtual int trybind (const char *name, void *&pointer);
        virtual int find (const char *name, void *&pointer);
        virtual int find (const char *name);
        virtual int unbind (const char *name);
        virtual int unbind (const char *name, void *&pointer);
        virtual int sync (ssize_t len = -1, int flags = MS_SYNC);
        virtual int sync (void *addr, size_t len, int flags = MS_SYNC);
        virtual int protect (ssize_t len = -1, int prot = PROT_RDWR);
        virtual int protect (
            void *addr,
            size_t len,
            int prot = PROT_RDWR
            );
        ALLOCATOR &alloc (void);
        virtual void print_stats (void) const;
        virtual void dump (void) const;
      private:
        ALLOCATOR allocator_;
    };

## Initialization.

    ACE_Allocator_Adapter (LPCTSTR pool_name = 0);

    inline ACE_Allocator_Adapter (
        LPCTSTR pool_name,
        LPCTSTR lock_name,
        MEMORY_POOL_OPTIONS options = 0
        );

Constructor (this has to be inline to avoid bugs with some C++ compilers.

    virtual ~ACE_Allocator_Adapter (void);

Destructor.

## Memory Management

    virtual void *malloc (size_t nbytes);

Allocate `nbytes`, but don't give them any initial value.

    virtual void *calloc (size_t nbytes, char initial_value = '  ');

Allocate `nbytes`, giving them all an `initial_value`.

    virtual void free (void *ptr);

Free `ptr` (must have been allocated by `ACE_Allocator::malloc`).

    virtual int remove (void);

Remove any resources associated with this memory manager.

## Map manager like functions

    virtual int bind (
        const char *name,
        void *pointer,
        int duplicates = 0
        );

Associate `name` with `pointer`. If `duplicates` == 0 then do not allow duplicate `name`/`pointer` associations, else if `duplicates` != 0 then allow duplicate `name`/`pointer` assocations. Returns 0 if successfully binds (1) a previously unbound `name` or (2) `duplicates` != 0, returns 1 if trying to bind a previously bound `name` and `duplicates` == 0, else returns -1 if a resource failure occurs.

    virtual int trybind (const char *name, void *&pointer);

Associate `name` with `pointer`. Does not allow duplicate `name`/`pointer` associations. Returns 0 if successfully binds (1) a previously unbound `name`, 1 if trying to bind a previously bound `name`, or returns -1 if a resource failure occurs. When this call returns `pointer`'s value will always reference the void * that `name` is associated with. Thus, if the caller needs to use `pointer` (e.g., to free it) a copy must be maintained by the caller.

    virtual int find (const char *name, void *&pointer);

Locate `name` and pass out parameter via pointer. If found, return 0, Returns -1 if `name` isn't found.

    virtual int find (const char *name);

Returns 0 if the name is in the mapping and -1 if not.

    virtual int unbind (const char *name);

Unbind (remove) the name from the map. Don't return the pointer to the caller

    virtual int unbind (const char *name, void *&pointer);

Break any association of name. Returns the value of pointer in case the caller needs to deallocate memory.

## Protection and

sync" (i.e., flushing data to backing store)."

    virtual int sync (ssize_t len = -1, int flags = MS_SYNC);

Sync `len` bytes of the memory region to the backing store starting at `this-`base_addr_. If `len` == -1 then sync the whole region.

    virtual int sync (void *addr, size_t len, int flags = MS_SYNC);

Sync `len` bytes of the memory region to the backing store starting at `addr_`.

    virtual int protect (ssize_t len = -1, int prot = PROT_RDWR);

Change the protection of the pages of the mapped region to `prot` starting at `this-`base_addr_ up to `len` bytes. If `len` == -1 then change protection of all pages in the mapped region.

    virtual int protect (void *addr, size_t len, int prot = PROT_RDWR);

Change the protection of the pages of the mapped region to `prot` starting at `addr` up to `len` bytes.

    ALLOCATOR &alloc (void);

Returns the underlying allocator.

    virtual void print_stats (void) const;

Dump statistics of how malloc is behaving.

    virtual void dump (void) const;

Dump the state of the object.

## AUTHOR

Doug Schmidt and Irfan Pyarali

## LIBRARY

ace