DECLARE_SERIALIZATION_FRIENDS
BPHASH_DECLARE_HASHING_FRIENDS
virtual void hash(bphash::Hasher & h) const
{
h(key_, required_, help_);
hash_(h);
}
bool validate(const std::string& pass, const std::string& hash)
{
assert(hash.size() == hash_len + SALT_LEN);
size_t salt_pos = hash.size() - SALT_LEN;
const std::string s = hash.substr(salt_pos);
const std::string h2 = hash_(s, pass);
return 0 == hash.compare(0, hash_len, h2);
}
BasicTimer::BasicTimer(const char* myname)
: hash(hash_(myname))
, starttime(spring_gettime())
{
nameIterator = hashToName.find(hash);
if (nameIterator == hashToName.end()) {
nameIterator = hashToName.insert(std::pair<int,std::string>(hash, myname)).first;
}
}
ULng32 NAHashDictionary<K,V>::getHashCode(const K& key) const
{
//#if defined(NA_UNIX) && !defined(NA_LINUX)
// use the key's hash method to get the hash value
// unsigned long hashValue = key.hash() % hashSize_;
//#else
ULng32 hashValue = hash_(key) % hashSize_;
//#endif
assert(hashValue < hashSize_);
return hashValue;
} // NAHashDictionary<K,V>::getHashCode()
void Scene::detachNamed(const std::string& name, const std::string& fullname, ComponentBase* aspect) {
aspect->setScene(nullptr);
foundation::hash::remove(componentByName_, hash_(fullname));
const foundation::Hash<ComponentBase*>::Entry* it = foundation::multi_hash::find_first(componentByObject_, hash_(name));
while (it != nullptr) {
if (it->value == aspect) {
foundation::multi_hash::remove(componentByObject_, it);
break;
}
it = foundation::multi_hash::find_next(componentByObject_, it);
}
}
int
find_empty(tw_event ** hash_t, tw_event * event, int hash_size)
{
unsigned int i;
int key;
i = 0;
key = hash_(event->event_id, hash_size);
if(0 > key)
tw_error(TW_LOC, "here!");
while (hash_t[key])
{
key += 2 * (++i) - 1;
if (key >= hash_size)
key -= hash_size;
}
return key;
}
bool cookie::parse_attr(std::string& name, std::string& value)
{
const std::size_t name_hash = hash_(name);
if (name_hash == domain_hash)
{
domain_.resize(name.size());
// lambda is required to build under gcc
std::transform(name.cbegin(), name.cend(), domain_.begin(), [](int c){ return std::tolower(c); });
}
else if (name_hash == path_hash)
{
path_.swap(value);
}
else if (name_hash == expires_hash)
{
if (expires_ == time_point::max())
{
auto utime = time_from_string(value, "%a, %d-%b-%Y %T %Z");
if (utime == -1)
return false;
expires_ = time_point::clock::from_time_t(utime);
}
}
else if (name_hash == max_age_hash)
{
expires_ = time_point::clock::now() + std::chrono::seconds(from_dec_string(value));
}
else if (name_hash == secure_hash)
{
secure_ = true;
}
else if (name_hash == http_only_hash)
{
http_only_ = true;
}
return true;
}
int
find_entry(tw_event ** hash_t, tw_event * event, int hash_size, int pe)
{
unsigned int i;
int key;
i = 0;
key = hash_(event->event_id, hash_size);
while (hash_t[key] == NULL || event->event_id != hash_t[key]->event_id)
{
key += 2 * (++i) - 1;
if (key >= hash_size)
key -= hash_size;
if (key > hash_size)
{
tw_error(TW_LOC, "Cannot find event in hash table: PE %d, key %d, size %d\n",
pe, key, hash_size);
}
}
return key;
}
virtual OutTypePtr Call(std::string *arg=nullptr) {
OKASSERT_FATAL(arg, "Programming error");
size_t hashed = hash_(*arg);
return MakeOwned(new std::string(Stringify(hashed)));
}
size_t operator()(const std::basic_string<CharT> &key) const {
return hash_(ToLower(key));
}
void Scene::attachNamed(const std::string& name, const std::string& fullname, ComponentBase* aspect) {
aspect->setName(name);
aspect->setScene(this);
foundation::hash::set(componentByName_, hash_(fullname), aspect);
foundation::multi_hash::insert(componentByObject_, hash_(name), aspect);
}
std::string hash(const std::string& pass)
{
const std::string s = rnd(SALT_LEN);
const std::string h = hash_(s, pass);
return h+s;
}
void taclex(const char *filename)
{
int c;
FILE *f;
uint16_t state = TAC_CLEAR;
char *buffer, *bptr, *fptr;
f = fopen(filename, "r");
if(!f){
perror("File IO Error");
exit(EXIT_FAILURE);
}
buffer = readfile(filename);
tacsym = hash_(pjw_hashf, str_isequalf);
for(fptr = bptr = buffer; *fptr != EOF; fptr++) {
switch(*fptr) {
case ' ':
case '\t':
case '\n':
case '\r':
case '\v':
state |= TAC_WHITESPACE;
break;
case ':':
state |= TAC_COL;
break;
case '_':
state |= TAC_UNDER;
break;
case '.':
state |= TAC_DOT;
break;
case '=':
state |= TAC_EQ;
break;
case '<':
state |= TAC_LESS;
break;
case '>':
state |= TAC_MORE;
break;
case '-':
state |= TAC_SUB;
break;
case '*':
state |= TAC_MUL;
break;
case '/':
state |= TAC_DIV;
break;
default:
if(
(*fptr >= 'a' && *fptr <= 'z') ||
(*fptr >= 'A' && *fptr <= 'Z')
) {
if(state | TAC_CLEAR)
state |= TAC_ALPHAFIRST;
state |= TAC_ALPHA;
}
else if(*fptr >= '1' && *fptr <= '9'){
state |= TAC_NUM;
}
else {
fprintf(stderr, "Lexical Error: Unknown Character: %c\n", *fptr);
}
break;
}
}
}
