/* -------------------------------------------------------------------------- *
* Create a game. *
* -------------------------------------------------------------------------- */
struct player *player_new(const char *name, int team, int accepted)
{
struct player *player;
/* allocate, zero and link game struct */
player = mem_static_alloc(&player_heap);
memset(player, 0, sizeof(struct player));
/* initialize the struct */
strlcpy(player->name, name, sizeof(player->name));
player->hash = strihash(player->name);
player->refcount = 1;
player->serial = player_serial;
player->team = team;
player->accepted = accepted;
dlink_list_zero(&player->cards);
dlink_add_tail(&player_list, &player->node, player);
debug(player_log, "Created player block: %s", player->name);
return player;
}
char *i18n_translate(const char *s)
{
struct map_entry *entry;
int hash = 0;
hash = strihash(s);
entry = hashmap_get_from_hash(&map, hash, s);
return entry ? (char *)get_value(entry) : NULL;
}
static void hashput(char *id, char *str)
{
int hash = 0;
struct map_entry *entry;
hash = strihash(id);
entry = alloc_entry(hash, id, strlen(id), str, strlen(str));
entry = hashmap_put(&map, entry);
/* If an entry has been replaced, free it */
xfree(entry);
}
void class_default(struct class *clptr)
{
dlink_node_zero(&clptr->node);
strcpy(clptr->name, "default");
clptr->ping_freq = 360;
clptr->max_players = 1000;
clptr->players_per_ip = 1;
clptr->recvq = (1 << 16);
clptr->sendq = (1 << 16);
clptr->flood_trigger = 0;
clptr->flood_interval = 0;
clptr->throttle_trigger = 0;
clptr->throttle_interval = 0;
clptr->hash = strihash(clptr->name);
}
/* -------------------------------------------------------------------------- *
* -------------------------------------------------------------------------- */
struct class *class_add(const char *name, uint64_t ping_freq,
uint32_t max_players, uint32_t players_per_ip,
uint32_t recvq, uint32_t sendq,
uint32_t flood_trigger, uint64_t flood_interval,
uint32_t throttle_trigger, uint64_t throttle_interval)
{
struct class *clptr;
/* allocate, zero and link class struct */
clptr = mem_static_alloc(&class_heap);
/*
* Read stdin line by line and print result of commands to stdout:
*
* hash key -> strhash(key) memhash(key) strihash(key) memihash(key)
* put key value -> NULL / old value
* get key -> NULL / value
* remove key -> NULL / old value
* iterate -> key1 value1\nkey2 value2\n...
* size -> tablesize numentries
*
* perfhashmap method rounds -> test hashmap.[ch] performance
*/
int main(int argc, char *argv[])
{
char line[1024];
struct hashmap map;
int icase;
/* init hash map */
icase = argc > 1 && !strcmp("ignorecase", argv[1]);
hashmap_init(&map, (hashmap_cmp_fn) (icase ? test_entry_cmp_icase
: test_entry_cmp), 0);
/* process commands from stdin */
while (fgets(line, sizeof(line), stdin)) {
char *cmd, *p1 = NULL, *p2 = NULL;
int l1 = 0, l2 = 0, hash = 0;
struct test_entry *entry;
/* break line into command and up to two parameters */
cmd = strtok(line, DELIM);
/* ignore empty lines */
if (!cmd || *cmd == '#')
continue;
p1 = strtok(NULL, DELIM);
if (p1) {
l1 = strlen(p1);
hash = icase ? strihash(p1) : strhash(p1);
p2 = strtok(NULL, DELIM);
if (p2)
l2 = strlen(p2);
}
if (!strcmp("hash", cmd) && l1) {
/* print results of different hash functions */
printf("%u %u %u %u\n", strhash(p1), memhash(p1, l1),
strihash(p1), memihash(p1, l1));
} else if (!strcmp("add", cmd) && l1 && l2) {
/* create entry with key = p1, value = p2 */
entry = alloc_test_entry(hash, p1, l1, p2, l2);
/* add to hashmap */
hashmap_add(&map, entry);
} else if (!strcmp("put", cmd) && l1 && l2) {
/* create entry with key = p1, value = p2 */
entry = alloc_test_entry(hash, p1, l1, p2, l2);
/* add / replace entry */
entry = hashmap_put(&map, entry);
/* print and free replaced entry, if any */
puts(entry ? get_value(entry) : "NULL");
free(entry);
} else if (!strcmp("get", cmd) && l1) {
/* lookup entry in hashmap */
entry = hashmap_get_from_hash(&map, hash, p1);
/* print result */
if (!entry)
puts("NULL");
while (entry) {
puts(get_value(entry));
entry = hashmap_get_next(&map, entry);
}
} else if (!strcmp("remove", cmd) && l1) {
/* setup static key */
struct hashmap_entry key;
hashmap_entry_init(&key, hash);
/* remove entry from hashmap */
entry = hashmap_remove(&map, &key, p1);
/* print result and free entry*/
puts(entry ? get_value(entry) : "NULL");
free(entry);
} else if (!strcmp("iterate", cmd)) {
struct hashmap_iter iter;
hashmap_iter_init(&map, &iter);
while ((entry = hashmap_iter_next(&iter)))
printf("%s %s\n", entry->key, get_value(entry));
} else if (!strcmp("size", cmd)) {
/* print table sizes */
printf("%u %u\n", map.tablesize, map.size);
} else if (!strcmp("intern", cmd) && l1) {
/* test that strintern works */
const char *i1 = strintern(p1);
const char *i2 = strintern(p1);
if (strcmp(i1, p1))
printf("strintern(%s) returns %s\n", p1, i1);
else if (i1 == p1)
printf("strintern(%s) returns input pointer\n", p1);
else if (i1 != i2)
printf("strintern(%s) != strintern(%s)", i1, i2);
else
printf("%s\n", i1);
} else if (!strcmp("perfhashmap", cmd) && l1 && l2) {
perf_hashmap(atoi(p1), atoi(p2));
} else {
printf("Unknown command %s\n", cmd);
}
}
hashmap_free(&map, 1);
return 0;
}
