示例#1
0
文件: lexer.cpp 项目: K-ballo/ki
    lexer::id_type lexer::add_literal( char const* literal )
    {
        static char const chars_to_escape[] = ".^$*+-?()[]{}|\\/";

        std::string const key = literal;
        id_type const token_id = get_next_id();

        std::string token_def;
        for( std::size_t start = 0; start < key.size(); )
        {
            std::size_t const next =
                key.find_first_of( chars_to_escape, start );

            std::size_t end;
            if( next != std::string::npos )
            {
                token_def.push_back( '\\' );
                end = next + 1;
            } else {
                end = key.size();
            }

            token_def.insert(
                token_def.end()
              , key.begin() + start, key.begin() + end
            );
            start = end;
        }
        self.add( token_def, token_id );
        tokens[ key ] = token_id;

        return token_id;
    }
示例#2
0
int GeUser::add_user(char* system, char* user, char* password, pwr_tMask priv,
    char* fullname, char* description, char* email, char* phone, char* sms,
    pwr_tOix id)
{
  SystemList* sl;
  int sts;

  // Find system
  SystemName* sn = new SystemName(system);
  sts = sn->parse();
  if (EVEN(sts)) {
    delete sn;
    return sts;
  }
  sl = find_system(sn);
  if (!sl)
    return USER__NOSUCHSYSTEM;

  if (id == user_cNId)
    id = get_next_id();
  else if (id >= next_id)
    next_id = id + 1;

  sl->add_user(
      id, user, password, priv, fullname, description, email, phone, sms);
  return USER__SUCCESS;
}
示例#3
0
    bool im_login_list::update(/*in, out*/ im_login_id& _login)
    {
        bool found = false;

        for (auto iter = logins_.begin(); iter != logins_.end(); ++iter)
        {
            if (iter->get_login() == _login.get_login())
            {
                found = true;

                _login = *iter;

                if (iter == logins_.begin())
                    return true;

                logins_.erase(iter);
                break;
            }
        }

        if (!found)
            _login.set_id(get_next_id());

        logins_.push_front(_login);

        save();
        return found;
    }
示例#4
0
    TEST(KeyBtreeTest, search)
    {
      StringBtree btree(TEST_KEY_MAX_SIZE);
      {
        TestKey key;
        int32_t j;
        int32_t *ids = (int32_t*)malloc(TEST_COUNT * sizeof(int32_t));

        for(int32_t i = 0; i < TEST_COUNT; i++)
        {
          if (get_next_id(j)) break;
          ids[i] = j;
          key.set_value(j);
          btree.put(key, j + 1);
        }

        // search
        int32_t value = 0;
        int32_t success = 0;
        for(int32_t i = 0; i < TEST_COUNT; i++)
        {
          key.set_value(ids[i]);
          btree.get(key, value);
          if (value == ids[i] + 1) success ++;
        }
        free(ids);
        EXPECT_EQ(success, TEST_COUNT);
      }
      btree.clear();
    }
示例#5
0
    TEST(KeyBtreeTest, put)
    {
      StringBtree btree(TEST_KEY_MAX_SIZE);
      {
        TestKey key;
        int32_t ret, j;
        int32_t success = 0;
        int32_t value = 0;

        for(int32_t i = 0; i < TEST_COUNT; i++)
        {
          if (get_next_id(j)) break;
          key.set_value(j);
          ret = btree.put(key, i + 1);
          if (ret == ERROR_CODE_OK)
          {
            success ++;
          }
        }
        EXPECT_EQ(success, btree.get_object_count());
        ret = btree.put(key, 1);
        EXPECT_EQ(ret, ERROR_CODE_KEY_REPEAT);
        ret = btree.put(key, 20, true);
        EXPECT_EQ(ret, ERROR_CODE_OK);
        EXPECT_EQ(btree.get(key, value), ERROR_CODE_OK);
        EXPECT_TRUE(value == 20);
        EXPECT_EQ(success, btree.get_object_count());
      }
      btree.clear();
    }
void
Pgr_linear<G>::add_shortcut(
        G &graph, V vertex,
        E incoming_edge,
        E outgoing_edge) {
    pgassert(incoming_edge != outgoing_edge);

    auto a = graph.adjacent(vertex, incoming_edge);
    auto c = graph.adjacent(vertex, outgoing_edge);
    pgassert(a != vertex);
    pgassert(a != c);
    pgassert(vertex != c);

    if (graph.is_undirected()) {
        Identifiers<V> adjacent_vertices = graph.find_adjacent_vertices(vertex);

        V vertex_1 = adjacent_vertices.front();
        adjacent_vertices.pop_front();
        V vertex_2 = adjacent_vertices.front();
        adjacent_vertices.pop_front();

        E shortcut_E;
        CH_edge shortcut(get_next_id(), graph[vertex_1].id,
                graph[vertex_2].id,
                graph[incoming_edge].cost + graph[outgoing_edge].cost);
        shortcut.add_contracted_vertex(graph[vertex], vertex);
        shortcut.add_contracted_edge_vertices(graph[incoming_edge]);
        shortcut.add_contracted_edge_vertices(graph[outgoing_edge]);
        debug << "Adding shortcut\n";
        debug << shortcut;
        graph.add_shortcut(shortcut);
        debug << "Added shortcut\n";
    } else {
        CH_edge shortcut(
                get_next_id(),
                graph[a].id,
                graph[c].id,
                graph[incoming_edge].cost + graph[outgoing_edge].cost);
        shortcut.add_contracted_vertex(graph[vertex], vertex);
        shortcut.add_contracted_edge_vertices(graph[incoming_edge]);
        shortcut.add_contracted_edge_vertices(graph[outgoing_edge]);
        debug << "Adding shortcut\n";
        debug << shortcut;
        graph.add_shortcut(shortcut);
        debug << "Added shortcut\n";
    }
}
示例#7
0
static BOOL create_poi (const char* name, RoadMapPosition* coordinates, BOOL overide, void * cursor){
   int id = get_next_id();
   if (id < 0)
      return FALSE;
   g_request_cursors[id] = cursor;
   roadmap_log( ROADMAP_DEBUG, "create_poi -  name = %s,lat-%d, lon=%d, id=%d",name, coordinates->latitude, coordinates->longitude, id );
   return Realtime_TripServer_CreatePOI(name, coordinates, overide,id);
}
示例#8
0
    TEST(KeyBtreeTest, insert_batch)
    {
      StringBtree btree(TEST_KEY_MAX_SIZE);
      {
        BtreeWriteHandle handle;

        TestKey key;
        int32_t ret, j;
        int32_t success = 0;
        int32_t value = 0;

        ret = btree.get_write_handle(handle);
        ASSERT_TRUE(ERROR_CODE_OK == ret);
        for(int32_t i = 0; i < TEST_COUNT; i++)
        {
          if (get_next_id(j)) break;
          key.set_value(j);
          ret = btree.put(handle, key, i + 1);
          if (ret == ERROR_CODE_OK)
          {
            success ++;
          }
        }
        handle.end();
        EXPECT_EQ(success, btree.get_object_count());
        {
          BtreeWriteHandle handle1;
          btree.get_write_handle(handle1);
          for(int32_t i = 0; i < TEST_COUNT; i++)
          {
            if (get_next_id(j)) break;
            key.set_value(j);
            btree.put(handle1, key, i + 1);
          }
          key.set_value(1000);
          btree.put(handle1, key, 1000);
          btree.get(handle1, key, value);
          EXPECT_EQ(1000, value);
          handle1.rollback();
        }
        EXPECT_EQ(success, btree.get_object_count());
      }
      btree.clear();
    }
示例#9
0
 virtual const object&  create( const std::function<void(object&)>& constructor ) override
 {
     auto id = get_next_id();
     auto instance = id.instance();
     if( instance >= _objects.size() ) _objects.resize( instance + 1 );
     _objects[instance].id = id;
     constructor( _objects[instance] );
     use_next_id();
     return _objects[instance];
 }
示例#10
0
 virtual const object&  create(const std::function<void(object&)>& constructor )override
 {
    ObjectType item;
    item.id = get_next_id();
    constructor( item );
    auto insert_result = _indices.insert( std::move(item) );
    FC_ASSERT(insert_result.second, "Could not create object! Most likely a uniqueness constraint is violated.");
    use_next_id();
    return *insert_result.first;
 }
// use this to spawn new actors on the current process
Actor* actor_train_protege (Actor *mentor, Role role, void *props){
  Actor *actor = _train_actor(mentor, get_next_id(), role, props);
  if(mentor->proteges != NULL){
    _add_new_protege(actor, mentor->proteges);
  }
  else{
    mentor->proteges = _train_protege(actor);
  }
  return actor;
}
示例#12
0
/* buys a pass
 *
 * returns the id of the newly created Pass
 */
int Pass_Buy(Pass *pass, UserType const user, TermType const term,
             TransType const trans, int const amount, time_t const expires) {
    pass->balance = amount;
    pass->trans = trans;
    pass->term = term;
    pass->user = user;
    pass->id = get_next_id();
    pass->expires = expires;

    return pass->id;
}
示例#13
0
文件: callback.hpp 项目: iwadon/junk
 // 登録
 CALLBACK_ID set(F func, void *arg)
 {
   Item *item = get_free_item();
   if (item == NULL) {
     return 0;
   }
   item->id = get_next_id();
   item->entry = func;
   item->arg = arg;
   return item->id;
 }
示例#14
0
 virtual const object&  create( const std::function<void(object&)>& constructor ) override
 {
     auto id = get_next_id();
     auto instance = id.instance();
     if( instance >= _objects.size() ) _objects.resize( instance + 1 );
     _objects[instance].reset(new T);
     _objects[instance]->id = id;
     constructor( *_objects[instance] );
     _objects[instance]->id = id; // just in case it changed
     use_next_id();
     return *_objects[instance];
 }
示例#15
0
void loop_and_count (pthread_t self, Environment *env)
{
    int id;
    
    while (1) {
    	id = get_next_id (env);
    	
    	// printf ("%d got %d\n", self, id);
    	
    	if (id >= SIZE) return;
        env->array[id]++;
    }
}
示例#16
0
    TEST(KeyBtreeTest, range_search)
    {
      StringBtree btree(TEST_KEY_MAX_SIZE);
      {
        BtreeReadHandle handle;

        TestKey key;
        int32_t j;
        int32_t *ids = (int32_t*)malloc(TEST_COUNT * sizeof(int32_t));
        int insert_total = 0;

        for(int32_t i = 0; i < TEST_COUNT; i++)
        {
          if (get_next_id(j)) break;
          ids[i] = j;
          key.set_value(j);
          if (ERROR_CODE_OK == btree.put(key, i + 1))
          {
            insert_total ++;
          }
        }

        // range search
        int32_t value = 0;
        int32_t success = 0;
        int32_t ret = btree.get_read_handle(handle);
        ASSERT_TRUE(ERROR_CODE_OK == ret);
        btree.set_key_range(handle, btree.get_min_key(), 0, btree.get_max_key(), 0);
        while(ERROR_CODE_OK == btree.get_next(handle, value))
        {
          success ++;
        }
        EXPECT_EQ(success, insert_total);

        success = 0;
        BtreeReadHandle handle1;
        btree.get_read_handle(handle1);
        btree.set_key_range(handle1, btree.get_max_key(), 1, btree.get_min_key(), 1);
        if (ERROR_CODE_OK == btree.get_next(handle1, key, value))
        {
          success ++;
        }
        while(ERROR_CODE_OK == btree.get_next(handle1, value))
        {
          success ++;
        }
        EXPECT_EQ(success, insert_total);
        free(ids);
      }
      btree.clear();
    }
示例#17
0
int GeUser::add_system(
    char* name, pwr_tMask attributes, char* description, pwr_tOix id)
{
  int sts;

  SystemName* sn = new SystemName(name);
  sts = sn->parse();
  if (EVEN(sts)) {
    delete sn;
    return sts;
  }

  if (id == user_cNId)
    id = get_next_id();
  else if (id >= next_id)
    next_id = id + 1;

  SystemList* sl = find_system(sn);
  if (sl)
    return USER__SYSTEMALREXIST;

  SystemName* parent = sn->parent();
  if (!parent) {
    SystemList* sl;

    SystemList* system_list
        = new SystemList(id, name, 0, attributes, description);
    // Insert as last sibling to root
    if (!root)
      root = system_list;
    else {
      for (sl = root; sl->next; sl = sl->next)
        ;
      sl->next = system_list;
    }
  } else {
    parent->parse();
    SystemList* sl = find_system(parent);
    if (!sl) {
      delete sn;
      delete parent;
      return USER__NOSUCHSYSTEM;
    }
    sl->add_system(id, sn, attributes, description);
    delete parent;
  }
  delete sn;
  return USER__SUCCESS;
}
示例#18
0
errval_t oct_sem_new(uint32_t* id, size_t value)
{
    // Find a valid ID for our next semaphore
    *id = get_next_id();
    //debug_printf("oct_sem_new id is: %d\n", *id);

    errval_t err = SYS_ERR_OK;
    for (size_t i=0; i < value; i++) {
        err = oct_sem_post(*id);
        if (err_is_fail(err)) {
            return err;
        }
    }

    return err;
}
示例#19
0
Matrix ParametricMesh::get_matrix(const std::string &sub_obj, const MtxParams &p) const
{
	if(sub_obj == name)
		return param == -1 ? mtx : mtx * p[param];

	const string subobj_id = get_next_id(sub_obj,name);

	for(const_sub_iterator i = sub_objs.begin(); i != sub_objs.end(); ++i) {
		if(subobj_id == i->name) {
			const Matrix &sub_mtx = i->get_matrix(sub_obj,p);
			return mtx * (param == -1 ? sub_mtx : p[param] * sub_mtx);
		}
	}

	throw_sub_obj_error(sub_obj,name);
	return Matrix();
}
示例#20
0
文件: apdb.c 项目: guoyu07/jff
unsigned
apdb_add_begin(apdb_t* db, size_t length)
{
    data_t data;

    assert(NULL != db && NONE == db->action && CAN_WRITE(db));
    assert(db->index_file_len <= db->index_mmap_len);

    if (db->error)
        return -1;

    if (SSIZE_MAX - db->index_len <= db->index_file_len) {
        DEBUG("index file too big");
        return -1;
    }
    if (SSIZE_MAX - ALIGN_UP(sizeof(data_t) + length, ALIGN_SIZE) <=
            db->data_file_len) {
        DEBUG("data file too big");
        return -1;
    }

    db->next_id = get_next_id(db);
    if (db->error || UINT_MAX == db->next_id /* avoid overflow */)
        return -1;

    db->next_length = length;
    db->next_offset = db->data_file_len;
    db->next_written = 0;

    data.guard = GUARD;
    data.flags = 0;
    data.id = db->next_id;
    data.length = length;

    ERRORP_IF(sizeof(data_t) != writen(db->data_fd, &data, sizeof(data_t)),
              "failed to write");

    db->data_file_len += sizeof(data_t);
    db->action = ADD;

    return data.id;

L_error:
    db->error = -1;
    return -1;
}
示例#21
0
    TEST(KeyBtreeTest, remove)
    {
      StringBtree btree(TEST_KEY_MAX_SIZE);
      {
        TestKey key;
        int32_t ret, j;
        int32_t *ids = (int32_t*)malloc(TEST_COUNT * sizeof(int32_t));
        int32_t success = 0;
        int value;

        for(int32_t i = 0; i < TEST_COUNT; i++)
        {
          if (get_next_id(j)) break;
          ids[i] = j;
          key.set_value(j);
          if (btree.put(key, i + 1) == ERROR_CODE_OK)
          {
            success ++;
          }
        }
        key.set_value(0x80000000);
        ASSERT_TRUE(btree.put(key, 0x8000001) == ERROR_CODE_OK);
        btree.remove(key, value);
        ASSERT_TRUE(value == 0x8000001);
        // remove
        for(int32_t i = 0; i < TEST_COUNT - 10; i++)
        {
          key.set_value(ids[i]);
          ret = btree.remove(key);
          if (ret == ERROR_CODE_OK)
          {
            success --;
          }
        }
        free(ids);
        EXPECT_EQ(success, btree.get_object_count());
      }
      btree.clear();
    }
示例#22
0
/******************************************************************************
 *                                                                            *
 * Function:                                                                  *
 *                                                                            *
 * Purpose:                                                                   *
 *                                                                            *
 * Parameters:                                                                *
 *                                                                            *
 * Return value:                                                              *
 *                                                                            *
 * Comments:                                                                  *
 *                                                                            *
 ******************************************************************************/
int register_db_table(JOBARG_EXEC_REQUEST er,
                      zbx_uint64_t * inner_jobnet_id, int cnt)
{
    const char *__function_name = "register_db_table";
    char *user_name = NULL;
    char *jobnet_name = NULL;
    char *memo = NULL;
    char *jobnetid;
    char *env;
    char *value;
    int ret = SUCCEED;
    int res;
    int public_flag = 0;
    int run_type;
    int multiple_start_up;
    int i;
    zbx_uint64_t next_id;
    zbx_uint64_t update_date;
    zbx_uint64_t scheduled_time;
    DB_RESULT result;
    DB_ROW row;
    zabbix_log(LOG_LEVEL_DEBUG, "In %s() jobnetid: [%s]",
               __function_name, er.jobnetid);
    jobnetid = DBdyn_escape_string(er.jobnetid);
    result =
        DBselect
        ("select update_date, public_flag, multiple_start_up, user_name, jobnet_name, memo"
         " from ja_jobnet_control_table" " where jobnet_id='%s'"
         " and valid_flag=1", jobnetid);
    row = DBfetch(result);
    if (row == NULL) {
        ja_log("JATRAPPER200014", 0, jobnetid, 0, jobnetid);
        zbx_free(jobnetid);
        DBfree_result(result);
        ret = FAIL;
        return ret;
    }
    ZBX_STR2UINT64(update_date, row[0]);
    public_flag = atoi(row[1]);
    multiple_start_up = atoi(row[2]);
    user_name = DBdyn_escape_string(row[3]);
    jobnet_name = DBdyn_escape_string(row[4]);
    memo = DBdyn_escape_string(row[5]);
    DBfree_result(result);
    if (er.starttime != NULL) {
        run_type = JA_JOBNET_RUN_TYPE_SCHEDULED;
        ZBX_STR2UINT64(scheduled_time, er.starttime);
    } else {
        run_type = JA_JOBNET_RUN_TYPE_IMMEDIATE;
        scheduled_time = 0;
    }
    next_id = get_next_id(JA_RUN_ID_JOBNET_EX, 0, jobnetid, 0);
    if (next_id == 0) {
        ja_log("JATRAPPER200015", 0, jobnetid, 0);
        zbx_free(jobnetid);
        zbx_free(user_name);
        zbx_free(jobnet_name);
        zbx_free(memo);
        ret = FAIL;
        return ret;
    }
    res = DBexecute("insert into ja_run_jobnet_table"
                    " (inner_jobnet_id, inner_jobnet_main_id,"
                    " update_date, run_type, main_flag, status, scheduled_time,"
                    " public_flag, multiple_start_up,"
                    " jobnet_id, user_name, jobnet_name, memo, execution_user_name)"
                    " values ( " ZBX_FS_UI64 ", " ZBX_FS_UI64 ", "
                    ZBX_FS_UI64 ", %d, %d, %d, " ZBX_FS_UI64
                    ", %d, %d,"
                    " '%s', '%s', '%s', '%s', '%s')",
                    next_id, next_id,
                    update_date, run_type, JA_JOBNET_MAIN_FLAG_MAIN, JA_JOBNET_STATUS_BEGIN, scheduled_time,
                    public_flag, multiple_start_up,
                    jobnetid, user_name, jobnet_name, memo, er.username);
    if (ZBX_DB_OK > res) {
        ja_log("JATRAPPER200016", 0, jobnetid, 0, jobnetid);
        zbx_free(jobnetid);
        zbx_free(user_name);
        zbx_free(jobnet_name);
        zbx_free(memo);
        ret = FAIL;
        return ret;
    }
    for (i = 0; i < cnt; i++) {
        env = NULL;
        value = NULL;
        env = DBdyn_escape_string(er.env[i]);
        value = DBdyn_escape_string(er.value[i]);
        res = DBexecute("insert into ja_value_before_jobnet_table"
                        " (inner_jobnet_id, value_name, before_value)"
                        " values ( " ZBX_FS_UI64 ", '%s', '%s' )",
                        next_id, env, value);
        if (ZBX_DB_OK > res) {
            ja_log("JATRAPPER200016", 0, jobnetid, 0, jobnetid);
            zbx_free(jobnetid);
            zbx_free(user_name);
            zbx_free(jobnet_name);
            zbx_free(memo);
            zbx_free(env);
            zbx_free(value);
            ret = FAIL;
            return ret;
        }
        zbx_free(env);
        zbx_free(value);
    }
    *inner_jobnet_id = next_id;
    zbx_free(jobnetid);
    zbx_free(user_name);
    zbx_free(jobnet_name);
    zbx_free(memo);
    zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);
    return ret;
}
示例#23
0
/*
 * ui_handle_keycode - handle ui keycode 
 *  @key : key except to be HANG, BACK, 1~6
 *  @return : status
 */
int ui_handle_keycode(int key)
{
    int cur_id, item_num;
    int next_id, parent_id;

    ACTION handler; 

    cur_id = get_cur_frame_id();

    if (key == BACK) {
        parent_id = get_parent_id(cur_id);
        if (cur_id == parent_id)
            return SUCCESS;

        pop_ui_statck();

        set_cur_frame_id(parent_id);
        show_current_ui(parent_id);

        return SUCCESS;
    }

    if (key == HANG) {
        cmd_resume_transact();

        set_cur_frame_id(cur_id);
        show_current_ui(cur_id);

        return SUCCESS;
    } 

    item_num = get_item_num(cur_id);

    if (key > (item_num - 1))
        return FAIL;

    next_id = get_next_id(cur_id, key);
    handler = get_next_action(cur_id, key);

    if (handler == NULL) {
        push_ui_statck(cur_id);

        set_cur_frame_id(next_id);
        show_current_ui(next_id);

        return SUCCESS;
    } else {
        handler();

        push_ui_statck(cur_id);

        if (next_id == CLEAN_UI) {
            /*
             * just for log out and shutdown 
             */
            clear_screen();
        } else {
            set_cur_frame_id(next_id);
            show_current_ui(next_id);
        }

        return SUCCESS;
    }    
}