libmcl-sys 0.1.2-rc1

This system crate provides Rust language bindings to the Minos Compute Library (MCL)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107


/**
 * \file
 * PTRHASH (PH) - A simple hash table
 */

#ifndef _PTR_HASH_H
#define _PTR_HASH_H

#include <stddef.h>
#include <stdint.h>

#define PH_ENTRY_DELETED ((void *)0x1)

struct ph_table {
	size_t mask;
	size_t count;
	void *buckets[0];
};

void hashlittle2( 
  const void *key,       /* the key to hash */
  size_t      length,    /* length of the key */
  uint32_t   *pc,        /* IN: primary initval, OUT: primary hash */
  uint32_t   *pb);       /* IN: secondary initval, OUT: secondary hash */

#define __ph_hash(key, len, h1, h2) hashlittle2(key, len, h1, h2)


/** 
 * Add an element to hash table, using a field as a key.
 * @param table: hash table pointer.
 * @param eptr: pointer to the element (struct) to add.
 * @param keyfield: name of the field containing the key (size is computed
 * automatically)
 * @return 0: if element was added, 1: if already present, -1: if table is full.
 */ 
#define ph_add(table, eptr, keyfield) \
	ph_add_generic(table, eptr, offsetof(typeof(*eptr), keyfield), sizeof((*eptr).keyfield))

/** 
 * Get an element from the hash table.
 * @param table: hash table pointer.
 * @param key: pointer to key bytes
 * @param keyfield: name of the field containing the key (size is computed
 * automatically)
 * @param out: pointer to the found element
 */ 
#define ph_get(table, key, keyfield, out) ({ \
	out = ph_get_generic(table, key, offsetof(typeof(*out), keyfield), sizeof((*out).keyfield)); \
})

/** 
 * Remove an element from the hash table.
 * @param table: hash table pointer.
 * @param key: pointer to key bytes
 * @param keyfield: name of the field containing the key (size is computed
 * automatically)
 * @param out: pointer to the removed element
 */ 
#define ph_remove(table, key, keyfield, out) ({ \
	out = ph_remove_generic(table, key, offsetof(typeof(*out), keyfield), sizeof((*out).keyfield)); \
})

struct ph_table *ph_init(size_t size);

/** 
 * Add an element to hash table, using key embedded in 'value' structure.
 * @param h: hash table pointer.
 * @param value: pointer to the element (struct) to add.
 * @param keyoff: offset in bytes of the key to use, in the *value structure.
 * @param keylen: length in bytes of the key.
 * @return 0 if element was added, 1 if already present, -1 if table is full.
 */ 
int ph_add_generic(struct ph_table *h, void *value, size_t keyoff, size_t keylen);

/** 
 * Get an element from hash table, using the specified key.
 * @param h: hash table pointer.
 * @param key: pointer to the key bytes.
 * @param keyoff: offset in bytes of the key to use, in the *ptr structure.
 * @param keylen: length in bytes of the key.
 * @return element pointer or NULL if not found.
 */ 
void *ph_get_generic(struct ph_table *h, const void *key, size_t keyoff, size_t keylen);

/** 
 * Remove an element from hash table, using the specified key.
 * @param h: hash table pointer.
 * @param key: pointer to the key bytes.
 * @param keyoff: offset in bytes of the key in the value structure.
 * @param keylen: length in bytes of the key.
 * @return element pointer or NULL if not found.
 */ 
void *ph_remove_generic(struct ph_table *h, const void *key, size_t keyoff, size_t keylen);

/** 
 * Returns the number of elements of the hash table.
 * @param h: hash table pointer.
 * @return number of elements currently stored
 */ 
static inline size_t ph_count(const struct ph_table *h)
{
	return h->count;
}

#endif