C++ djb2_hash函数代码示例

void GlobalGroupFlag::AddFlag(const char *flag_id)
{
	const unsigned int hash_id = djb2_hash((unsigned char *) flag_id);

	std::multimap<const unsigned int, FlagAccessSwitch, ltint>::iterator p;
	flag_list.insert(std::make_pair(hash_id, FlagAccessSwitch(flag_id, true)));
}

int
pk_send(int id, Packet * pckt, int nbytes)
{
	int n, len;
	struct sockaddr * addr;

	UdpPacket udp_pckt;
	memcpy(&(udp_pckt.pckt), pckt, sizeof(Packet));
	udp_pckt.checksum = djb2_hash((char *) pckt, sizeof(Packet));	

	if (id == SRV_ID) { // sending from client to server
		addr = (struct sockaddr *) &srvaddr;
		len = sizeof srvaddr;
	} else { // sending from server to client
		addr = (struct sockaddr *) &cliaddr;
		len = sizeof cliaddr;
	}

	n = sendto(sockfd, &udp_pckt, sizeof udp_pckt, 0, addr, len);
	if (n == -1) {
		printf("Error sending packet.\n");
		return -1;
	}

	return n;
}

int main(void)
{
    gnrc_netreg_entry_t ne;

    uint8_t cpuid[CPUID_LEN];
    cpuid_get(cpuid);
    conn_test_id = djb2_hash(cpuid, CPUID_LEN);
    random_init(conn_test_id);

    ne.pid = thread_create(_stack, sizeof(_stack), THREAD_PRIORITY_MAIN - 1,
                             THREAD_CREATE_STACKTEST, _listener, NULL,
                             "listener");

    ne.demux_ctx = GNRC_NETREG_DEMUX_CTX_ALL;
    gnrc_netreg_register(GNRC_NETTYPE_UNDEF, &ne);

    puts("Connectivity Test program!");
    printf("MY ID: %08lX\n", (unsigned long) conn_test_id);
    unsigned res = CONN_TEST_CHAN;
    if (gnrc_netapi_set(CONN_TEST_NETIF, NETOPT_CHANNEL, 0, (uint16_t *)&res, sizeof(uint16_t)) < 0) {
        puts("main: error setting channel");
    }

    unsigned int addr_len = 8;
    if (gnrc_netapi_set(CONN_TEST_NETIF, NETOPT_SRC_LEN, 0, (uint16_t *)&addr_len, sizeof(uint16_t)) < 0) {
        printf("main: error setting addressing mode\n");
    }
    xtimer_set_msg(&ct_timer, (SEC_IN_USEC * 3) + (random_uint32() & 0x001FFFFF), &ct_m, ne.pid);

    char line_buf[SHELL_DEFAULT_BUFSIZE];
    shell_run(shell_commands, line_buf, SHELL_DEFAULT_BUFSIZE);
    return 0;
}

bool CharacterDB::del_name_validation_set( uint32 characterID )
{
	CharIdNameMapItr helper_itr = mIdNameContainer.find(characterID);

	/* if we are unable to find the entry... return.
	 * @note we do risk keeping the name in the name validation. 
	 * which I am willing to take.
	 */
	if (helper_itr == mIdNameContainer.end())
		return false;

	const char* name = helper_itr->second.c_str();
	if (name == NULL || *name == '\0')
		return false;

	uint32 hash = djb2_hash(name);

	CharValidationSetItr name_itr = mNameValidation.find(hash);
	if (name_itr != mNameValidation.end())
	{
		// we found the name hash... deleting
		mNameValidation.erase(name_itr);
		mIdNameContainer.erase(helper_itr);
		return true;
	}
	else
	{
		/* normally this should never happen... */
		printf("CharacterDB::del_name_validation_set: unable to remove: %s as its not in the set", name);
		return false;
	}
}

void CharacterDB::load_name_validation_set()
{
	DBQueryResult res;
	if(!sDatabase.RunQuery(res,
		"SELECT"
		" characterID, itemName AS characterName"
		" FROM character_"
		"	JOIN entity ON characterID = itemID"
		))
	{
		codelog(SERVICE__ERROR, "Error in query for %s", res.error.c_str());
		return;
	}

	DBResultRow row;
	while(res.GetRow(row) == true)
	{
		uint32 characterID = row.GetUInt(0);
		const char* name = row.GetText(1);

		//printf("initializing name validation: %s\n", name);
		uint32 hash = djb2_hash(name);

		mNameValidation.insert(hash);
		mIdNameContainer.insert(std::make_pair(characterID, name));
	}
}

int
pk_receive(int id, Packet * pckt, int nbytes)
{
	int n, len;
	struct sockaddr * addr;

	UdpPacket udp_pckt;
	
	if (id != SRV_ID) { // client receiving
		len = sizeof srvaddr;
		addr = (struct sockaddr *) &srvaddr;
	} else { // server receiving
		len = sizeof cliaddr;
		addr = (struct sockaddr *) &cliaddr;
	}

	n = recvfrom(sockfd, &udp_pckt, sizeof udp_pckt, 0, addr, (socklen_t *) &len);
	if (n == -1) {
		printf("Error receiving packet.\n");
		return -1;
	}

	unsigned long checksum;
	checksum = djb2_hash((char *) &(udp_pckt.pckt), sizeof(Packet));
	if (checksum == udp_pckt.checksum) {
		memcpy(pckt, &(udp_pckt.pckt), sizeof(Packet));
	} else {
		return -1;
	}

	return n;
}

int snippet_library::add_snippet( const std::string &category, const std::string &text )
{
    int hash = djb2_hash( ( const unsigned char * )text.c_str() );
    snippets.insert( std::pair<int, std::string>( hash, text ) );
    categories.insert( std::pair<std::string, int>( category, hash ) );
    return hash;
}

/* Finds the address where the pointer should be (whether or not it is there)
 * So that we can add it if we want
 * returns 0 if it exists, 1 otherwise
 */
static int __get_bucket_addr(hash h, char* key, bucket** ret) {
    char* lower_key = str_to_lower(key);
    unsigned int i = djb2_hash(lower_key) % (h -> size);
    free(lower_key);
    int found = 0;
    bucket* it = &(h -> table)[i];
    bucket* head = it;

    // try to find it in the current bucket
    while(*it && !found) {
        if( strcasecmp( (*it) -> key, key) == 0 )
            found = 1;
        else
            it = &( (*it) -> next );
    }

    // if we found a bucket, we need to return it
    if(*it)
        *ret = it;
    else
        *ret = head; // otherwise return where it should be (head of the bucket)

    // returning the flag
    return found;
}

const struct macro *definition(struct token name)
{
    struct macro *ref;
    unsigned long hash, pos;

    if (name.token != IDENTIFIER)
        return NULL;

    hash = djb2_hash(name.strval);
    pos = hash % HASH_TABLE_LENGTH;
    ref = &macro_hash_table[pos];
    if (!ref->name.strval) {
        return NULL;
    }

    while ((ref->hash.val != hash || strcmp(ref->name.strval, name.strval)) &&
            ref->hash.next)
        ref = ref->hash.next;

    if (ref->hash.val == hash && !strcmp(ref->name.strval, name.strval)) {
        if (!strcmp(ref->name.strval, "__LINE__")) {
            ref->replacement[0].token.intval = current_file.line;
        }
        return ref;
    }

    return NULL;
}

/* adrpo: see the comment above about djb2 hash */
modelica_integer stringHashDjb2(metamodelica_string_const s)
{
  const char* str = MMC_STRINGDATA(s);
  long res = djb2_hash((const unsigned char*)str);
  res = labs(res);
  /* fprintf(stderr, "stringHashDjb2 %s-> %ld %ld %ld\n", str, res, mmc_mk_icon(res), mmc_unbox_integer(mmc_mk_icon(res))); */
  return res;
}

void snippet_library::load_snippet(JsonObject &jsobj)
{
    std::string category = jsobj.get_string("category");
    std::string text = _(jsobj.get_string("text").c_str());
    int hash = djb2_hash( (const unsigned char*)text.c_str() );

    snippets.insert( std::pair<int, std::string>(hash, text) );
    categories.insert( std::pair<std::string, int>(category, hash) );
}

static unsigned int relation_salt_cpp(const td_scanner *scanner)
{
	int i, count;
	unsigned int hash = 0;
	for (i = 0, count = scanner->path_count; i < count; ++i)
	{
		hash ^= (unsigned int) djb2_hash(scanner->include_paths[i]->path);
	}
	return hash;
}

/* adrpo: see the comment above about djb2 hash */
modelica_integer stringHashDjb2Mod(metamodelica_string_const s, modelica_integer mod)
{
  const char* str = MMC_STRINGDATA(s);
  long res;
  if (mod == 0) {
    MMC_THROW();
  }
  res = djb2_hash((const unsigned char*)str) % (unsigned int) mod;
  res = labs(res);
  /* fprintf(stderr, "stringHashDjb2Mod %s %ld-> %ld %ld %ld\n", str, mod, res, mmc_mk_icon(res), mmc_unbox_integer(mmc_mk_icon(res))); */
  return res;
}

entry *findName(char lastname[], entry *pHead[])
{
    unsigned long i;
    i = djb2_hash((unsigned char *)lastname)%SIZE_OF_TABLE;
    entry *e = pHead[i];

    while (e != NULL) {
        if (strcasecmp(lastname, e->lastName) == 0)
            return e;
        e = e->pNext;
    }
    return NULL;
}

void define(struct macro macro)
{
    static int clean_on_exit;

    struct macro *ref;
    unsigned long
        hash = djb2_hash(macro.name.strval),
        pos = hash % HASH_TABLE_LENGTH;

    if (!clean_on_exit) {
        atexit(cleanup);
        clean_on_exit = 1;
    }

    ref = &macro_hash_table[pos];
    if (!ref->name.strval) {
        *ref = macro;
        ref->hash.val = hash;
        return;
    }

    while ((ref->hash.val != hash
            || strcmp(ref->name.strval, macro.name.strval)) && ref->hash.next)
        ref = ref->hash.next;

    if (ref->hash.val == hash && !strcmp(ref->name.strval, macro.name.strval)) {
        if (macrocmp(ref, &macro)) {
            error("Redefinition of macro '%s' with different substitution.",
                macro.name.strval);
            exit(1);
        }
        /* Already have this definition, but need to clean up memory that we
         * took ownership of. */
        if (macro.size) {
            free(macro.replacement);
        }
        return;
    }

    assert(!ref->hash.next);
    ref->hash.next = calloc(1, sizeof(*ref));
    ref = ref->hash.next;
    *ref = macro;
    ref->hash.val = hash;
}