---
name: "ACE_Allocator_Adapter"
section: "3"
platform: "linux"
package: "libace-doc"
version: "5.0.7-4"
release: "Debian 2.2 (Potato)"
platforms: ["linux"]
url: "https://new.carta.tech/ACE_Allocator_Adapter"
---

# ACE\_Allocator\_Adapter(3)

This class is an Adapter that allows the ACE\_Allocator to use the Malloc class below.

## 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