## hash

hash —

## Synopsis

    struct      xmlHashTable;
    typedef     xmlHashTablePtr;
    void        (*xmlHashDeallocator)           (void *payload,
                                                 xmlChar *name);
    void*       (*xmlHashCopier)                (void *payload,
                                                 xmlChar *name);
    void        (*xmlHashScanner)               (void *payload,
                                                 void *data,
                                                 xmlChar *name);
    void        (*xmlHashScannerFull)           (void *payload,
                                                 void *data,
                                                 const xmlChar *name,
                                                 const xmlChar *name2,
                                                 const xmlChar *name3);
    xmlHashTablePtr xmlHashCreate               (int size);
    void        xmlHashFree                     (xmlHashTablePtr table,
                                                 xmlHashDeallocator f);
    int         xmlHashAddEntry                 (xmlHashTablePtr table,
                                                 const xmlChar *name,
                                                 void *userdata);
    int         xmlHashUpdateEntry              (xmlHashTablePtr table,
                                                 const xmlChar *name,
                                                 void *userdata,
                                                 xmlHashDeallocator f);
    int         xmlHashAddEntry2                (xmlHashTablePtr table,
                                                 const xmlChar *name,
                                                 const xmlChar *name2,
                                                 void *userdata);
    int         xmlHashUpdateEntry2             (xmlHashTablePtr table,
                                                 const xmlChar *name,
                                                 const xmlChar *name2,
                                                 void *userdata,
                                                 xmlHashDeallocator f);
    int         xmlHashAddEntry3                (xmlHashTablePtr table,
                                                 const xmlChar *name,
                                                 const xmlChar *name2,
                                                 const xmlChar *name3,
                                                 void *userdata);
    int         xmlHashUpdateEntry3             (xmlHashTablePtr table,
                                                 const xmlChar *name,
                                                 const xmlChar *name2,
                                                 const xmlChar *name3,
                                                 void *userdata,
                                                 xmlHashDeallocator f);
    int         xmlHashRemoveEntry              (xmlHashTablePtr table,
                                                 const xmlChar *name,
                                                 xmlHashDeallocator f);
    int         xmlHashRemoveEntry2             (xmlHashTablePtr table,
                                                 const xmlChar *name,
                                                 const xmlChar *name2,
                                                 xmlHashDeallocator f);
    int         xmlHashRemoveEntry3             (xmlHashTablePtr table,
                                                 const xmlChar *name,
                                                 const xmlChar *name2,
                                                 const xmlChar *name3,
                                                 xmlHashDeallocator f);
    void*       xmlHashLookup                   (xmlHashTablePtr table,
                                                 const xmlChar *name);
    void*       xmlHashLookup2                  (xmlHashTablePtr table,
                                                 const xmlChar *name,
                                                 const xmlChar *name2);
    void*       xmlHashLookup3                  (xmlHashTablePtr table,
                                                 const xmlChar *name,
                                                 const xmlChar *name2,
                                                 const xmlChar *name3);
    xmlHashTablePtr xmlHashCopy                 (xmlHashTablePtr table,
                                                 xmlHashCopier f);
    int         xmlHashSize                     (xmlHashTablePtr table);
    void        xmlHashScan                     (xmlHashTablePtr table,
                                                 xmlHashScanner f,
                                                 void *data);
    void        xmlHashScan3                    (xmlHashTablePtr table,
                                                 const xmlChar *name,
                                                 const xmlChar *name2,
                                                 const xmlChar *name3,
                                                 xmlHashScanner f,
                                                 void *data);
    void        xmlHashScanFull                 (xmlHashTablePtr table,
                                                 xmlHashScannerFull f,
                                                 void *data);
    void        xmlHashScanFull3                (xmlHashTablePtr table,
                                                 const xmlChar *name,
                                                 const xmlChar *name2,
                                                 const xmlChar *name3,
                                                 xmlHashScannerFull f,
                                                 void *data);

## Description

## Details

### struct xmlHashTable

    struct xmlHashTable;

### xmlHashTablePtr

    typedef xmlHashTable *xmlHashTablePtr;

### xmlHashDeallocator ()

    void        (*xmlHashDeallocator)           (void *payload,
                                                 xmlChar *name);

Callback to free data from a hash.

`payload` : | the data in the hash
`name` : | the name associated

### xmlHashCopier ()

    void*       (*xmlHashCopier)                (void *payload,
                                                 xmlChar *name);

Callback to copy data from a hash.

`payload` : | the data in the hash
`name` : | the name associated

### xmlHashScanner ()

    void        (*xmlHashScanner)               (void *payload,
                                                 void *data,
                                                 xmlChar *name);

Callback when scanning data in a hash with the simple scanner.

`payload` : | the data in the hash
`data` : | extra scannner data
`name` : | the name associated

### xmlHashScannerFull ()

    void        (*xmlHashScannerFull)           (void *payload,
                                                 void *data,
                                                 const xmlChar *name,
                                                 const xmlChar *name2,
                                                 const xmlChar *name3);

Callback when scanning data in a hash with the full scanner.

`payload` : | the data in the hash
`data` : | extra scannner data
`name` : | the name associated
`name2` : | the second name associated
`name3` : | the third name associated

### xmlHashCreate ()

    xmlHashTablePtr xmlHashCreate               (int size);

Create a new xmlHashTablePtr.

`size` : | the size of the hash table
Returns : | the newly created object, or NULL if an error occured.

### xmlHashFree ()

    void        xmlHashFree                     (xmlHashTablePtr table,
                                                 xmlHashDeallocator f);

Free the hash `table` and its contents. The userdata is deallocated with `f` if provided.

`table` : | the hash table
`f` : | the deallocator function for items in the hash

### xmlHashAddEntry ()

    int         xmlHashAddEntry                 (xmlHashTablePtr table,
                                                 const xmlChar *name,
                                                 void *userdata);

Add the `userdata` to the hash `table`. This can later be retrieved by using the `name`. Duplicate names generate errors.

`table` : | the hash table
`name` : | the name of the userdata
`userdata` : | a pointer to the userdata
Returns : | 0 the addition succeeded and -1 in case of error.

### xmlHashUpdateEntry ()

    int         xmlHashUpdateEntry              (xmlHashTablePtr table,
                                                 const xmlChar *name,
                                                 void *userdata,
                                                 xmlHashDeallocator f);

Add the `userdata` to the hash `table`. This can later be retrieved by using the `name`. Existing entry for this `name` will be removed and freed with `f` if found.

`table` : | the hash table
`name` : | the name of the userdata
`userdata` : | a pointer to the userdata
`f` : | the deallocator function for replaced item (if any)
Returns : | 0 the addition succeeded and -1 in case of error.

### xmlHashAddEntry2 ()

    int         xmlHashAddEntry2                (xmlHashTablePtr table,
                                                 const xmlChar *name,
                                                 const xmlChar *name2,
                                                 void *userdata);

Add the `userdata` to the hash `table`. This can later be retrieved by using the (`name`, `name2`) tuple. Duplicate tuples generate errors.

`table` : | the hash table
`name` : | the name of the userdata
`name2` : | a second name of the userdata
`userdata` : | a pointer to the userdata
Returns : | 0 the addition succeeded and -1 in case of error.

### xmlHashUpdateEntry2 ()

    int         xmlHashUpdateEntry2             (xmlHashTablePtr table,
                                                 const xmlChar *name,
                                                 const xmlChar *name2,
                                                 void *userdata,
                                                 xmlHashDeallocator f);

Add the `userdata` to the hash `table`. This can later be retrieved by using the (`name`, `name2`) tuple. Existing entry for this tuple will be removed and freed with `f` if found.

`table` : | the hash table
`name` : | the name of the userdata
`name2` : | a second name of the userdata
`userdata` : | a pointer to the userdata
`f` : | the deallocator function for replaced item (if any)
Returns : | 0 the addition succeeded and -1 in case of error.

### xmlHashAddEntry3 ()

    int         xmlHashAddEntry3                (xmlHashTablePtr table,
                                                 const xmlChar *name,
                                                 const xmlChar *name2,
                                                 const xmlChar *name3,
                                                 void *userdata);

Add the `userdata` to the hash `table`. This can later be retrieved by using the tuple (`name`, `name2`, `name3`). Duplicate entries generate errors.

`table` : | the hash table
`name` : | the name of the userdata
`name2` : | a second name of the userdata
`name3` : | a third name of the userdata
`userdata` : | a pointer to the userdata
Returns : | 0 the addition succeeded and -1 in case of error.

### xmlHashUpdateEntry3 ()

    int         xmlHashUpdateEntry3             (xmlHashTablePtr table,
                                                 const xmlChar *name,
                                                 const xmlChar *name2,
                                                 const xmlChar *name3,
                                                 void *userdata,
                                                 xmlHashDeallocator f);

Add the `userdata` to the hash `table`. This can later be retrieved by using the tuple (`name`, `name2`, `name3`). Existing entry for this tuple will be removed and freed with `f` if found.

`table` : | the hash table
`name` : | the name of the userdata
`name2` : | a second name of the userdata
`name3` : | a third name of the userdata
`userdata` : | a pointer to the userdata
`f` : | the deallocator function for replaced item (if any)
Returns : | 0 the addition succeeded and -1 in case of error.

### xmlHashRemoveEntry ()

    int         xmlHashRemoveEntry              (xmlHashTablePtr table,
                                                 const xmlChar *name,
                                                 xmlHashDeallocator f);

Find the userdata specified by the `name` and remove it from the hash `table`. Existing userdata for this tuple will be removed and freed with `f`.

`table` : | the hash table
`name` : | the name of the userdata
`f` : | the deallocator function for removed item (if any)
Returns : | 0 if the removal succeeded and -1 in case of error or not found.

### xmlHashRemoveEntry2 ()

    int         xmlHashRemoveEntry2             (xmlHashTablePtr table,
                                                 const xmlChar *name,
                                                 const xmlChar *name2,
                                                 xmlHashDeallocator f);

Find the userdata specified by the (`name`, `name2`) tuple and remove it from the hash `table`. Existing userdata for this tuple will be removed and freed with `f`.

`table` : | the hash table
`name` : | the name of the userdata
`name2` : | a second name of the userdata
`f` : | the deallocator function for removed item (if any)
Returns : | 0 if the removal succeeded and -1 in case of error or not found.

### xmlHashRemoveEntry3 ()

    int         xmlHashRemoveEntry3             (xmlHashTablePtr table,
                                                 const xmlChar *name,
                                                 const xmlChar *name2,
                                                 const xmlChar *name3,
                                                 xmlHashDeallocator f);

Find the userdata specified by the (`name`, `name2`, `name3`) tuple and remove it from the hash `table`. Existing userdata for this tuple will be removed and freed with `f`.

`table` : | the hash table
`name` : | the name of the userdata
`name2` : | a second name of the userdata
`name3` : | a third name of the userdata
`f` : | the deallocator function for removed item (if any)
Returns : | 0 if the removal succeeded and -1 in case of error or not found.

### xmlHashLookup ()

    void*       xmlHashLookup                   (xmlHashTablePtr table,
                                                 const xmlChar *name);

Find the userdata specified by the `name`.

`table` : | the hash table
`name` : | the name of the userdata

### xmlHashLookup2 ()

    void*       xmlHashLookup2                  (xmlHashTablePtr table,
                                                 const xmlChar *name,
                                                 const xmlChar *name2);

Find the userdata specified by the (`name`, `name2`) tuple.

`table` : | the hash table
`name` : | the name of the userdata
`name2` : | a second name of the userdata

### xmlHashLookup3 ()

    void*       xmlHashLookup3                  (xmlHashTablePtr table,
                                                 const xmlChar *name,
                                                 const xmlChar *name2,
                                                 const xmlChar *name3);

Find the userdata specified by the (`name`, `name2`, `name3`) tuple.

`table` : | the hash table
`name` : | the name of the userdata
`name2` : | a second name of the userdata
`name3` : | a third name of the userdata

### xmlHashCopy ()

    xmlHashTablePtr xmlHashCopy                 (xmlHashTablePtr table,
                                                 xmlHashCopier f);

Scan the hash `table` and applied `f` to each value.

`table` : | the hash table
`f` : | the copier function for items in the hash
Returns : | the new table or NULL in case of error.

### xmlHashSize ()

    int         xmlHashSize                     (xmlHashTablePtr table);

Query the number of elements installed in the hash `table`.

`table` : | the hash table
Returns : | the number of elements in the hash table or -1 in case of error

### xmlHashScan ()

    void        xmlHashScan                     (xmlHashTablePtr table,
                                                 xmlHashScanner f,
                                                 void *data);

Scan the hash `table` and applied `f` to each value.

`table` : | the hash table
`f` : | the scanner function for items in the hash
`data` : | extra data passed to f

### xmlHashScan3 ()

    void        xmlHashScan3                    (xmlHashTablePtr table,
                                                 const xmlChar *name,
                                                 const xmlChar *name2,
                                                 const xmlChar *name3,
                                                 xmlHashScanner f,
                                                 void *data);

Scan the hash `table` and applied `f` to each value matching (`name`, `name2`, `name3`) tuple. If one of the names is null, the comparison is considered to match.

`table` : | the hash table
`name` : | the name of the userdata or NULL
`name2` : | a second name of the userdata or NULL
`name3` : | a third name of the userdata or NULL
`f` : | the scanner function for items in the hash
`data` : | extra data passed to f

### xmlHashScanFull ()

    void        xmlHashScanFull                 (xmlHashTablePtr table,
                                                 xmlHashScannerFull f,
                                                 void *data);

Scan the hash `table` and applied `f` to each value.

`table` : | the hash table
`f` : | the scanner function for items in the hash
`data` : | extra data passed to f

### xmlHashScanFull3 ()

    void        xmlHashScanFull3                (xmlHashTablePtr table,
                                                 const xmlChar *name,
                                                 const xmlChar *name2,
                                                 const xmlChar *name3,
                                                 xmlHashScannerFull f,
                                                 void *data);

Scan the hash `table` and applied `f` to each value matching (`name`, `name2`, `name3`) tuple. If one of the names is null, the comparison is considered to match.

`table` : | the hash table
`name` : | the name of the userdata or NULL
`name2` : | a second name of the userdata or NULL
`name3` : | a third name of the userdata or NULL
`f` : | the scanner function for items in the hash
`data` : | extra data passed to f