bool PptvMedia::parse_video_param( Video & video, std::string const & param) { boost::system::error_code ec; ec || (ec = map_find(param, "name", video.name, "&")) || (ec = map_find(param, "bitrate", video.bitrate, "&")) || (ec = map_find(param, "duration", video.duration, "&")); return !ec; }
bool PptvMedia::parse_jump_param( Jump & jump, std::string const & param) { boost::system::error_code ec; ec || (ec = map_find(param, "svrhost", jump.server_host, "&")) || (ec = map_find(param, "svrtime", jump.server_time, "&")) || (ec = map_find(param, "bakhost", jump.back_host, "&")) || (ec = map_find(param, "bwtype", jump.bw_type, "&")); return !ec; }
/* * Finds node in the map. * * @author Lukasz Koprowski <*****@*****.**> * @return Either node ot a parent it'd have. */ snode * map_find(snode * root, long long int key){ if (root == NULL ) { return NULL; } else if (root -> key == key || root -> key == EMPTY_KEY) { return root; } else if (root -> key > key) { if(root -> right == NULL) return root; return map_find(root -> right, key); } else { if(root -> left == NULL) return root; return map_find(root -> left, key); } }
int main() { int i; map_init(); map_insert("nihao",1); map_insert("nishi",2); map_insert("nishi",3); map_delete("nishi"); printf("%d %d\n",map_find("nishi"),map_find("nihao")); printf("\n"); return 0; }
void sys_seek(int fd, unsigned position) { struct file* file = map_find(get_filemap(), fd); if (file != NULL && position <= (unsigned)sys_filesize(fd)) file_seek(file, position); }
static int header(gpt_t gpt) { unsigned int revision; map_t map; struct gpt_hdr *hdr; char buf[128]; gpt_show_num("Media Size", (uintmax_t)gpt->mediasz); printf("Sector Size: %u\n", gpt->secsz); gpt_show_num("Number of Sectors", (uintmax_t)(gpt->mediasz / gpt->secsz)); printf("\nHeader Information:\n"); map = map_find(gpt, MAP_TYPE_PRI_GPT_HDR); if (map == NULL) { printf("- GPT Header not found\n"); return 0; } hdr = map->map_data; revision = le32toh(hdr->hdr_revision); printf("- GPT Header Revision: %u.%u\n", revision >> 16, revision & 0xffff); gpt_show_num("- First Data Sector", hdr->hdr_lba_start); gpt_show_num("- Last Data Sector", hdr->hdr_lba_end); gpt_uuid_snprintf(buf, sizeof(buf), "%d", hdr->hdr_guid); printf("- Media GUID: %s\n", buf); printf("- Number of GPT Entries: %u\n", hdr->hdr_entries); return 0; }
Symbol * Env_get_prot(Env * env, char * id) { void * found; for (; env != NULL; env = env->prev) if (( found = map_find(&env->prot_table, id) ) != NULL) return *((Symbol **) found); return NULL; }
/* * Insert symbol into environment. If the symbol is already in the environment, * return 0. Otherwise, insert it and return 1 */ int Env_put(Env * env, char * id, Symbol * sym) { if (map_find(&env->table, id) != NULL) return 0; if (sym->type != TYPE_FN) if (map_find(&env->prot_table, id) != NULL) return 0; //sym->scope = env; if (sym->type == TYPE_FN_PROT) map_insert(&env->prot_table, id, sym); else map_insert(&env->table, id, sym); return 1; }
static obj_ptr _map_find(obj_ptr args, obj_ptr env) { int ct = _length(args); obj_ptr map, key, res; if (ct < 2 || ct > 3) return MKERROR_STRING(MKSTRING("Syntax: (map-find map key [default])")); map = CAR(args); if (NMAPP(map)) return MKERROR(MKSTRING("Expected a map in first arg to map-find"), map); key = CADR(args); res = map_find(&MAP(map), key); if (!res) { if (ct == 3) return CADDR(args); else return MKERROR(MKSTRING("Key not found."), key); } return res; }
void plist_set_exit_status(struct map* m, key_t k, int status) { lock_acquire(&plist_lock); struct process* p = map_find(m, k); p->exit_status = status; lock_release(&plist_lock); }
struct process* plist_find_process(struct map* m, key_t k) { lock_acquire(&plist_lock); struct process* p = map_find(m, k); lock_release(&plist_lock); return p; }
void ProgramProfiler::log_stats(const std::map<const void *, size_t> &linenos) { std::unique_lock<std::mutex> lock(s_mutex); for (ProgramProfiler *instance : s_instances) { instance->unsafe_report(); } std::vector<LogLine> log_lines; double total_sec = 0; for (auto &pair : s_stats) { size_t lineno = map_find(linenos, pair.first); Stat &stat = pair.second; log_lines.push_back({stat, lineno}); total_sec += stat.time * 1e-6; stat.count = 0; stat.time = 0; } std::sort(log_lines.begin(), log_lines.end()); POMAGMA_INFO("Profile of VirtualMachine programs:"); POMAGMA_INFO(" Line Calls Percent Total sec Per call sec"); POMAGMA_INFO("----- ----------- ------- ----------- ------------"); for (const auto &line : log_lines) { double time_sec = line.stat.time * 1e-6; double percent = 100 * time_sec / total_sec; POMAGMA_INFO(std::fixed << std::setprecision(2) << std::setw(5) << std::right << line.lineno << std::setw(12) << std::right << line.stat.count << std::setw(8) << std::right << percent << std::setw(12) << time_sec << std::setw(10) << (time_sec / line.stat.count)); } }
/* A function that given an integer (obtained from above function) and a process id FIND the file in a list. Should return NULL if the specified process did not insert the file or already removed it. */ value_t flist_find_file(int fd, struct thread* t) { value_t v = map_find(&(t->open_files), fd); return v; }
static task_t *tasks_find(task_id tid) { task_t f = { tid }; lc_spin_lock(lock); task_t *t = map_find(tasks, &f); lc_spin_unlock(lock); return t; }
static void add_depend(const char *source, set_t *incl, map_t *deps) { set_t *mydeps; llnode_t *tmp; int i,num; if (source == NULL) return; mydeps = map_find(deps,source); if (mydeps != NULL) { num = mydeps->nbuckets; for (i = 0; i < num; ++i) { tmp = mydeps->buckets + i; while (tmp->next != NULL) { if (set_find(incl,tmp->key) == 0) { set_add(incl,tmp->key); add_depend(tmp->key,incl,deps); } tmp = tmp->next; } } } }
void *map_get_ref(map *m, char *key) { int idx = map_find(m, key); if(idx < 0) return NULL; return &m->values[idx]; }
static inline int __search_avp_map(str *alias, map_t m) { int **id = (int **)map_find(m, *alias); LM_DBG("looking for [%.*s] avp %s - found %d\n", alias->len, alias->s, m == avp_map_shm ? "in shm": "", id ? p2int(*id) : -1); return id ? p2int(*id) : -1; }
/** * Skriver till fd (skärm eller fil) * Returnerar antalet skrivna tecken eller -1 om antalet tecken som ska skrivas * är 0 eller om filen inte finns. */ int sys_write(int fd, const void* buffer, unsigned length) { if (fd == STDIN_FILENO) // Vi kan inte skriva till tangentbordet { return -1; } if (fd == STDOUT_FILENO) // skärmen { putbuf(buffer, length); return length; } else { // Skriva till fil struct file* write_to = map_find(get_filemap(), fd); if(write_to != NULL) { // Skriver buffer till write_to. Returnerar antalet skrivna tecken // Kan returnera ett antal tecken < length om filen är för liten return file_write(write_to, buffer, length); } else { return -1; // Filen finns inte, eller så ville vi skriva 0 tecken. } } // Hit ska vi inte komma! }
/* * Inserts element into the map. * * @author Lukasz Koprowski <*****@*****.**> */ int map_put(snode * root, char * key, int value) { if(key[0] == '\0') return SUCCESS; snode * node = malloc(sizeof(snode)); if(node == NULL){ error(ERR_NOT_ENOUGH_MEMORY); } node -> key = get_hashcode(key); node -> value = value; node -> left = NULL; node -> right = NULL; snode * fnode = map_find(root, node -> key); if (fnode -> key == EMPTY_KEY) { fnode -> key = node -> key; fnode -> value = node -> value; free(node); } else if (fnode -> key > node -> key) { fnode -> right = node; } else { fnode -> left = node; } return SUCCESS; }
void map_del(struct map_t* map, const char* key) { struct map_find_results_t find_results = map_find(map, key); if (!find_results.exact_match) { return; } struct map_node_t* node = find_results.node; if (map->free_func && node->value) { (*map->free_func)(node->value); } if (node == map->head) { map->head = map->head->next; } else { find_results.prev_node->next = node->next; } free(node->key); free(node); map->size--; }
void tech_free(void* ptr) { phashnode_t node; node = map_find(memory, ptr); assert (node); FreeMem(ptr, (uint32)node->value); }
unsigned sys_tell (int fd) { struct file* file = map_find(get_filemap(), fd); if (file != NULL) return file_tell(file); return -1; }
int sys_filesize(int fd) { struct file* file = map_find(get_filemap(), fd); if (file != NULL) return file_length(file); return -1; }
void map_rm(map *m, char *key, void (*destroy_callback)(void*)) { int idx = map_find(m, key); if(idx < 0) return; list_rm_at(idx, &m->keys, &free); list_rm_at(idx, &m->values, destroy_callback); }
void sys_close(int fd) { struct file* close_file = map_find(get_filemap(), fd); if(close_file != NULL) { filesys_close(close_file); map_remove(get_filemap(), fd); // important to remove from file hEHE } }
int_str_t *kv_get(map_t _store, const str* _key) { int_str_t **val; val = (int_str_t **)map_find(_store, *_key); if (val) return *val; return NULL; }
static struct auth_profile *get_profile_by_name(char *uname) { int i; i=map_find(uname); if (i==MAP_NOT_FOUND) return 0; else return (struct auth_profile *)i; }
void* map_get(struct map_t* map, const char* key) { const struct map_find_results_t find_result = map_find(map, key); if (find_result.exact_match) { return find_result.node->value; } return NULL; }
void va_attribute_count_add( int size, int count, container *attributes, int argc, va_list *ap ) { ant[0]++; int i; char *id = va_arg(*ap, char*); container *subattr; iterator it = map_find(attributes, id); if (it.valid) { ant[1]++; subattr = pair(map_val(it)).first.ptr; container *M = pair(map_val(it)).second.ptr; it = map_find(M, count); if (it.valid) { ant[2]++; map_val(it).i+= size; } else { ant[3]++; map_insert(M, count, size); } //for (i=0; i<len; i++) //((int*)pair(map_val(it)).second.ptr)[i]+= count[i]; } else { ant[4]++; subattr = map_container( string_container(), pair_container( ptr_container(), ptr_container() ) ); container *M = map_container( int_container(), int_container() ); map_insert(M, count, size); //int *C = malloc(sizeof(int)*len); //for (i=0; i<len; i++) C[i] = count[i]; map_insert(attributes, id, subattr, M); } if (argc > 1) va_attribute_count_add( size, count, subattr, argc-1, ap ); }
task_t *task_ref(task_id tid) { task_t f = { tid }; lc_spin_lock(lock); task_t *t = map_find(tasks, &f); if (t) { atomic_int_inc(&t->ref_count); } lc_spin_unlock(lock); return t; }