自学教程：C++ vector_at函数代码示例

int fdset_poll2(fdset *fds) {    int r, i;    while (1) {        FD_ZERO(&fds->rfds);        FD_ZERO(&fds->exfds);        FD_ZERO(&fds->wfds);        fds->max_fd = -1;        if (vector_empty(&fds->rev) && vector_empty(&fds->exev)) {            // We have nothing left to select(2) on.            return 0;        }        fdset_populate(fds, &fds->rfds, &fds->rev);        fdset_populate(fds, &fds->exfds, &fds->exev);        r = select(fds->max_fd+1, &fds->rfds, 0, &fds->exfds, &fds->timeout);        if (r < 0) {            if (errno != EINTR) {                perror("select");                return r;            }            continue;        }        if (r == 0) {            // Timeout case            fds->timeout_cb(NULL);            continue;        }        for (i = 0; i < vector_size(&fds->rev); ++i) {            select_event_t *pse = (select_event_t*)vector_at(&fds->rev, i);            if (FD_ISSET(pse->fd, &fds->rfds)) {                VERBOSE("FD %d is read ready/n", pse->fd);                pse->callback(pse->opaque);            }        }        for (i = 0; i < vector_size(&fds->exev); ++i) {            int rev_pos;            select_event_t se;            se = *(select_event_t*)vector_at(&fds->exev, i);            if (FD_ISSET(se.fd, &fds->exfds)) {                INFO("FD %d is in ERROR/n", se.fd);                // Also remove this fd from the list of ex/read events                // to monitor.                vector_erase(&fds->exev, i);                --i;                // Remove from read events list as well.                rev_pos = algorithm_find(&fds->rev, &se.fd, find_by_fd);                if (rev_pos != -1) {                    vector_erase(&fds->rev, rev_pos);                }                se.callback(se.opaque);            } // if ()        } // for ()    } // while (1)} // fdset_poll2()

/** * Erases all the elements of an hashtable. */void _hashtable_clear(_hashtable_t* pt_hashtable){    size_t       t_bucketcount = 0;    size_t       i = 0;    _hashnode_t* pt_node = NULL;    _hashnode_t* pt_deletion = NULL;    bool_t       b_result = false;    assert(pt_hashtable != NULL);    assert(_hashtable_is_inited(pt_hashtable) || _hashtable_is_created(pt_hashtable));    t_bucketcount = vector_size(&pt_hashtable->_vec_bucket);    /* iterator all bucket node */    for(i = 0; i < t_bucketcount; ++i)    {        /* iterator all element list for one bucket node */        pt_node = *(_hashnode_t**)vector_at(&pt_hashtable->_vec_bucket, i);        *(_hashnode_t**)vector_at(&pt_hashtable->_vec_bucket, i) = NULL;        while(pt_node != NULL)        {            /* delete each element */            pt_deletion = pt_node;            pt_node = pt_node->_pt_next;            /* destroy element */            b_result = _GET_HASHTABLE_TYPE_SIZE(pt_hashtable);            _GET_HASHTABLE_TYPE_DESTROY_FUNCTION(pt_hashtable)(pt_deletion->_pby_data, &b_result);            assert(b_result);            _alloc_deallocate(&pt_hashtable->_t_allocator,  pt_deletion,                 _HASHTABLE_NODE_SIZE(_GET_HASHTABLE_TYPE_SIZE(pt_hashtable)), 1);        }    }        pt_hashtable->_t_nodecount = 0;}

/* ============================================================================= * net_isCycle * ============================================================================= */bool_tnet_isCycle (net_t* netPtr){    vector_t* nodeVectorPtr = netPtr->nodeVectorPtr;    long numNode = vector_getSize(nodeVectorPtr);    long n;    for (n = 0; n < numNode; n++) {        net_node_t* nodePtr = (net_node_t*)vector_at(nodeVectorPtr, n);        nodePtr->mark = NET_NODE_MARK_INIT;    }    for (n = 0; n < numNode; n++) {        net_node_t* nodePtr = (net_node_t*)vector_at(nodeVectorPtr, n);        switch (nodePtr->mark) {            case NET_NODE_MARK_INIT:                if (isCycle(nodeVectorPtr, nodePtr)) {                    return TRUE;                }                break;            case NET_NODE_MARK_DONE:                /* do nothing */                break;            case NET_NODE_MARK_TEST:                assert(0);                break;            default:                assert(0);                break;        }    }    return FALSE;}

static voidtester (long geneLength, long segmentLength, long minNumSegment, bool_t doPrint){    gene_t* genePtr;    segments_t* segmentsPtr;    random_t* randomPtr;    bitmap_t* startBitmapPtr;    long i;    long j;    genePtr = gene_alloc(geneLength);    segmentsPtr = segments_alloc(segmentLength, minNumSegment);    randomPtr = random_alloc();    startBitmapPtr = bitmap_alloc(geneLength);    random_seed(randomPtr, 0);    gene_create(genePtr, randomPtr);    random_seed(randomPtr, 0);    segments_create(segmentsPtr, genePtr, randomPtr);    assert(segmentsPtr->minNum == minNumSegment);    assert(vector_getSize(segmentsPtr->contentsPtr) >= minNumSegment);    if (doPrint) {        printf("Gene = %s/n", genePtr->contents);    }    /* Check that each segment occurs in gene */    for (i = 0; i < vector_getSize(segmentsPtr->contentsPtr); i++) {        char *charPtr = strstr(genePtr->contents,                               (char*)vector_at(segmentsPtr->contentsPtr, i));        assert(charPtr != NULL);        j = charPtr - genePtr->contents;        bitmap_set(startBitmapPtr, j);        if (doPrint) {            printf("Segment %li (@%li) = %s/n",                   i, j, (char*)vector_at(segmentsPtr->contentsPtr, i));        }    }    /* Check that there is complete overlap */    assert(bitmap_isSet(startBitmapPtr, 0));    for (i = 0, j = 0; i < geneLength; i++ ) {        if (bitmap_isSet(startBitmapPtr, i)) {           assert((i-j-1) < segmentLength);           j = i;        }    }    gene_free(genePtr);    segments_free(segmentsPtr);    random_free(randomPtr);    bitmap_free(startBitmapPtr);}

void test_vector_copy() {  vector* v = create_test_vector();  vector* copy = vector_copy(v);  int* v_element =  (int*)vector_at(v, 5);  int* copy_element =  (int*)vector_at(copy, 5);  printf("v[5] = %i at %p/n", *v_element, v_element);  printf("v[5] = %i at %p/n", *copy_element, copy_element);  vector_free(v, NULL);}

/* ============================================================================= * TMnet_findAncestors * -- Contents of bitmapPtr set to 1 if ancestor, else 0 * -- Returns false if id is not root node (i.e., has cycle back id) * ============================================================================= */bool_tTMnet_findAncestors (TM_ARGDECL                     net_t* netPtr,                     long id,                     bitmap_t* ancestorBitmapPtr,                     queue_t* workQueuePtr){    bool_t status;    vector_t* nodeVectorPtr = netPtr->nodeVectorPtr;    assert(ancestorBitmapPtr->numBit == vector_getSize(nodeVectorPtr));    PBITMAP_CLEARALL(ancestorBitmapPtr);    PQUEUE_CLEAR(workQueuePtr);    {        net_node_t* nodePtr = (net_node_t*)vector_at(nodeVectorPtr, id);        list_t* parentIdListPtr = nodePtr->parentIdListPtr;        list_iter_t it;        TMLIST_ITER_RESET(&it, parentIdListPtr);        while (TMLIST_ITER_HASNEXT(&it, parentIdListPtr)) {            long parentId = (long)TMLIST_ITER_NEXT(&it, parentIdListPtr);            status = PBITMAP_SET(ancestorBitmapPtr, parentId);            assert(status);            status = PQUEUE_PUSH(workQueuePtr, (void*)parentId);            assert(status);        }    }    while (!PQUEUE_ISEMPTY(workQueuePtr)) {        long parentId = (long)PQUEUE_POP(workQueuePtr);        if (parentId == id) {            PQUEUE_CLEAR(workQueuePtr);            return FALSE;        }        net_node_t* nodePtr = (net_node_t*)vector_at(nodeVectorPtr, parentId);        list_t* grandParentIdListPtr = nodePtr->parentIdListPtr;        list_iter_t it;        TMLIST_ITER_RESET(&it, grandParentIdListPtr);        while (TMLIST_ITER_HASNEXT(&it, grandParentIdListPtr)) {            long grandParentId = (long)TMLIST_ITER_NEXT(&it, grandParentIdListPtr);            if (!PBITMAP_ISSET(ancestorBitmapPtr, grandParentId)) {                status = PBITMAP_SET(ancestorBitmapPtr, grandParentId);                assert(status);                status = PQUEUE_PUSH(workQueuePtr, (void*)grandParentId);                assert(status);            }        }    }    return TRUE;}

/* ============================================================================= * TMnet_findDescendants * -- Contents of bitmapPtr set to 1 if descendants, else 0 * -- Returns false if id is not root node (i.e., has cycle back id) * ============================================================================= */bool_tTMnet_findDescendants (TM_ARGDECL                       net_t* netPtr,                       long id,                       bitmap_t* descendantBitmapPtr,                       queue_t* workQueuePtr){    bool_t status;    vector_t* nodeVectorPtr = netPtr->nodeVectorPtr;    assert(descendantBitmapPtr->numBit == vector_getSize(nodeVectorPtr));    PBITMAP_CLEARALL(descendantBitmapPtr);    PQUEUE_CLEAR(workQueuePtr);    {        net_node_t* nodePtr = (net_node_t*)vector_at(nodeVectorPtr, id);        list_t* childIdListPtr = nodePtr->childIdListPtr;        list_iter_t it;        TMLIST_ITER_RESET(&it, childIdListPtr);        while (TMLIST_ITER_HASNEXT(&it, childIdListPtr)) {            long childId = (long)TMLIST_ITER_NEXT(&it, childIdListPtr);            status = PBITMAP_SET(descendantBitmapPtr, childId);            assert(status);            status = PQUEUE_PUSH(workQueuePtr, (void*)childId);            assert(status);        }    }    while (!PQUEUE_ISEMPTY(workQueuePtr)) {        long childId = (long)PQUEUE_POP(workQueuePtr);        if (childId == id) {            queue_clear(workQueuePtr);            return FALSE;        }        net_node_t* nodePtr = (net_node_t*)vector_at(nodeVectorPtr, childId);        list_t* grandChildIdListPtr = nodePtr->childIdListPtr;        list_iter_t it;        TMLIST_ITER_RESET(&it, grandChildIdListPtr);        while (TMLIST_ITER_HASNEXT(&it, grandChildIdListPtr)) {            long grandChildId = (long)TMLIST_ITER_NEXT(&it, grandChildIdListPtr);            if (!PBITMAP_ISSET(descendantBitmapPtr, grandChildId)) {                status = PBITMAP_SET(descendantBitmapPtr, grandChildId);                assert(status);                status = PQUEUE_PUSH(workQueuePtr, (void*)grandChildId);                assert(status);            }        }    }    return TRUE;}

/* ============================================================================= * net_findAncestors * -- Contents of bitmapPtr set to 1 if ancestor, else 0 * -- Returns false if id is not root node (i.e., has cycle back id) * ============================================================================= */bool_tnet_findAncestors (net_t* netPtr,                   long id,                   bitmap_t* ancestorBitmapPtr,                   queue_t* workQueuePtr){    bool_t status;    vector_t* nodeVectorPtr = LocalLoad(&netPtr->nodeVectorPtr);    assert(LocalLoad(&ancestorBitmapPtr->numBit) == vector_getSize(nodeVectorPtr));    bitmap_clearAll(ancestorBitmapPtr);    queue_clear(workQueuePtr);    {        net_node_t* nodePtr = (net_node_t*)vector_at(nodeVectorPtr, id);        list_t* parentIdListPtr = LocalLoad(&nodePtr->parentIdListPtr);        list_iter_t it;        list_iter_reset(&it, parentIdListPtr);        while (list_iter_hasNext(&it, parentIdListPtr)) {            long parentId = (long)list_iter_next(&it, parentIdListPtr);            status = bitmap_set(ancestorBitmapPtr, parentId);            assert(status);            status = queue_push(workQueuePtr, (void*)parentId);            assert(status);        }    }    while (!queue_isEmpty(workQueuePtr)) {        long parentId = (long)queue_pop(workQueuePtr);        if (parentId == id) {            queue_clear(workQueuePtr);            return FALSE;        }        net_node_t* nodePtr = (net_node_t*)vector_at(nodeVectorPtr, parentId);        list_t* grandParentIdListPtr = LocalLoad(&nodePtr->parentIdListPtr);        list_iter_t it;        list_iter_reset(&it, grandParentIdListPtr);        while (list_iter_hasNext(&it, grandParentIdListPtr)) {            long grandParentId = (long)list_iter_next(&it, grandParentIdListPtr);            if (!bitmap_isSet(ancestorBitmapPtr, grandParentId)) {                status = bitmap_set(ancestorBitmapPtr, grandParentId);                assert(status);                status = queue_push(workQueuePtr, (void*)grandParentId);                assert(status);            }        }    }    return TRUE;}

/* ============================================================================= * net_findDescendants * -- Contents of bitmapPtr set to 1 if descendants, else 0 * -- Returns false if id is not root node (i.e., has cycle back id) * ============================================================================= */bool_tnet_findDescendants (net_t* netPtr,                     long id,                     bitmap_t* descendantBitmapPtr,                     queue_t* workQueuePtr){    bool_t status;    vector_t* nodeVectorPtr = netPtr->nodeVectorPtr;    assert(descendantBitmapPtr->numBit == vector_getSize(nodeVectorPtr));    bitmap_clearAll(descendantBitmapPtr);    queue_clear(workQueuePtr);    {        net_node_t* nodePtr = (net_node_t*)vector_at(nodeVectorPtr, id);        list_t* childIdListPtr = nodePtr->childIdListPtr;        list_iter_t it;        list_iter_reset(&it, childIdListPtr);        while (list_iter_hasNext(&it, childIdListPtr)) {            long childId = (long)list_iter_next(&it, childIdListPtr);            status = bitmap_set(descendantBitmapPtr, childId);            assert(status);            status = queue_push(workQueuePtr, (void*)childId);            assert(status);        }    }    while (!queue_isEmpty(workQueuePtr)) {        long childId = (long)queue_pop(workQueuePtr);        if (childId == id) {            queue_clear(workQueuePtr);            return FALSE;        }        net_node_t* nodePtr = (net_node_t*)vector_at(nodeVectorPtr, childId);        list_t* grandChildIdListPtr = nodePtr->childIdListPtr;        list_iter_t it;        list_iter_reset(&it, grandChildIdListPtr);        while (list_iter_hasNext(&it, grandChildIdListPtr)) {            long grandChildId = (long)list_iter_next(&it, grandChildIdListPtr);            if (!bitmap_isSet(descendantBitmapPtr, grandChildId)) {                status = bitmap_set(descendantBitmapPtr, grandChildId);                assert(status);                status = queue_push(workQueuePtr, (void*)grandChildId);                assert(status);            }        }    }    return TRUE;}

/* ============================================================================= * TMremoveEdge * ============================================================================= */static voidTMremoveEdge (TM_ARGDECL  net_t* netPtr, long fromId, long toId){    vector_t* nodeVectorPtr = netPtr->nodeVectorPtr;    bool_t status;    net_node_t* childNodePtr = (net_node_t*)vector_at(nodeVectorPtr, toId);    list_t* parentIdListPtr = childNodePtr->parentIdListPtr;    status = TMLIST_REMOVE(parentIdListPtr, (void*)fromId);    assert(status);    net_node_t* parentNodePtr = (net_node_t*)vector_at(nodeVectorPtr, fromId);    list_t* childIdListPtr = parentNodePtr->childIdListPtr;    status = TMLIST_REMOVE(childIdListPtr, (void*)toId);    assert(status);}

/* ============================================================================= * isCycle * ============================================================================= */static bool_tisCycle (vector_t* nodeVectorPtr, net_node_t* nodePtr){    switch (nodePtr->mark) {        case NET_NODE_MARK_INIT: {            nodePtr->mark = NET_NODE_MARK_TEST;            list_t* childIdListPtr = nodePtr->childIdListPtr;            list_iter_t it;            list_iter_reset(&it, childIdListPtr);            while (list_iter_hasNext(&it, childIdListPtr)) {                long childId = (long)list_iter_next(&it, childIdListPtr);                net_node_t* childNodePtr =                    (net_node_t*)vector_at(nodeVectorPtr, childId);                if (isCycle(nodeVectorPtr, childNodePtr)) {                    return TRUE;                }            }            break;        }        case NET_NODE_MARK_TEST:            return TRUE;        case NET_NODE_MARK_DONE:            return FALSE;            break;        default:            assert(0);    }    nodePtr->mark = NET_NODE_MARK_DONE;    return FALSE;}

/* ============================================================================= * net_alloc * ============================================================================= */net_t*net_alloc (long numNode){    net_t* netPtr;    netPtr = (net_t*)SEQ_MALLOC(sizeof(net_t));    if (netPtr) {        vector_t* nodeVectorPtr = vector_alloc(numNode);        if (nodeVectorPtr == NULL) {            SEQ_FREE(netPtr);            return NULL;        }        long i;        for (i = 0; i < numNode; i++) {            net_node_t* nodePtr = allocNode(i);            if (nodePtr == NULL) {                long j;                for (j = 0; j < i; j++) {                    nodePtr = (net_node_t*)vector_at(nodeVectorPtr, j);                    freeNode(nodePtr);                }                vector_free(nodeVectorPtr);                SEQ_FREE(netPtr);                return NULL;            }            bool_t status = vector_pushBack(nodeVectorPtr, (void*)nodePtr);            assert(status);        }        netPtr->nodeVectorPtr = nodeVectorPtr;    }    return netPtr;}

/* ============================================================================= * insertEdge * ============================================================================= */static voidinsertEdge (net_t* netPtr, long fromId, long toId){    vector_t* nodeVectorPtr = netPtr->nodeVectorPtr;    bool_t status;    net_node_t* childNodePtr = (net_node_t*)vector_at(nodeVectorPtr, toId);    list_t* parentIdListPtr = childNodePtr->parentIdListPtr;    status = list_insert(parentIdListPtr, (void*)fromId);    assert(status);    net_node_t* parentNodePtr = (net_node_t*)vector_at(nodeVectorPtr, fromId);    list_t* childIdListPtr = parentNodePtr->childIdListPtr;    status = list_insert(childIdListPtr, (void*)toId);    assert(status);}

/* XXX Not using */si_t application_quit(){    si_t i, n;    struct object * addr;    /* 有多少个窗口 */    n = vector_size(&(global_application.window_vector));    /* 依次删除窗口 */    for(i = n - 1; i >= 0; -- i)    {        addr = vector_at(&global_application.window_vector, i);        /*           这里没有逐个注销窗口类对象或者它的派生类对象。           因为窗口管理程序收到用户应用程序的退出请求后，           会释放关于这个用户应用程序的所有资源。           */        /* 释放这棵树 */        object_tree_free(addr->parent);        /* 从窗口向量中删除这个节点 */        vector_erase(&global_application.window_vector, i);    }    vector_exit(&global_application.window_vector);	event_listener_exit(&global_application.app_event_listener);    uds_exit(&global_application.uds);	free(global_application.name);    return 0;}

EXPORT_SYM enum sl_errorsl_flat_map_find_pair  (struct sl_flat_map* map,    const void* key,    struct sl_pair* pair){  size_t id = 0;  size_t len = 0;  enum sl_error sl_err = SL_NO_ERROR;  if(!map || !key || !pair) {    sl_err = SL_INVALID_ARGUMENT;    goto error;  }  sl_err = sl_flat_set_find(map->key_set, key, &id);  if(sl_err != SL_NO_ERROR)    goto error;  SL(flat_set_length(map->key_set, &len));  if(id == len) {    pair->key = NULL;    pair->data = NULL;  } else {    SL(vector_at(map->data_list, id, &(pair->data)));    SL(flat_set_at(map->key_set, id, &(pair->key)));  }exit:  return sl_err;error:  goto exit;}

static longcountData (data_t* dataPtr, vector_t* queryVectorPtr){    long count = 0;    long numQuery = vector_getSize(queryVectorPtr);    long r;    long numRecord = dataPtr->numRecord;    for (r = 0; r < numRecord; r++) {        char* record = data_getRecord(dataPtr, r);        bool_t isMatch = TRUE;        long q;        for (q = 0; q < numQuery; q++) {            query_t* queryPtr = (query_t*)vector_at(queryVectorPtr, q);            long queryValue = queryPtr->value;            if ((queryValue != QUERY_VALUE_WILDCARD) &&                ((char)queryValue) != record[queryPtr->index])            {                isMatch = FALSE;                break;            }        }        if (isMatch) {            count++;        }    }    return count;}

static void update_view(void){  struct mem_domain *d = vector_at(&domains, view_domain_index);  if (d->size <= MEM_VIEW_SIZE || d->view_offset < 0)    d->view_offset = 0;  else if (d->view_offset + MEM_VIEW_SIZE > d->size)    d->view_offset = d->size - MEM_VIEW_SIZE;  menu_intinput_set(view_address, d->start + d->view_offset);  strcpy(view_domain_name->text, d->name);  view_pageup->enabled = view_pagedown->enabled = (d->size > MEM_VIEW_SIZE);  for (int y = 0; y < MEM_VIEW_ROWS; ++y) {    struct menu_item *row = view_rows[y];    row->enabled = (d->view_offset + y * MEM_VIEW_COLS < d->size);    if (row->enabled)      sprintf(view_rows[y]->text, "%08x",              d->start + d->view_offset + y * MEM_VIEW_COLS);    for (int x = 0; x < MEM_VIEW_COLS; ++x) {      int n = y * MEM_VIEW_COLS + x;      if (n % view_data_size != 0)        continue;      struct menu_item *cell = view_cells[n];      cell->enabled = (d->view_offset + n < d->size);      if (cell->enabled)        cell->think_proc(cell);    }  }}

static voidTMremoveEdge (al_t* lock, net_t* netPtr, long fromId, long toId){    vector_t* nodeVectorPtr = LocalLoad(&netPtr->nodeVectorPtr);    bool_t status;    net_node_t* childNodePtr = (net_node_t*)vector_at(nodeVectorPtr, toId);    list_t* parentIdListPtr = LocalLoad(&childNodePtr->parentIdListPtr);    status = TMLIST_REMOVE(lock, parentIdListPtr, (void*)fromId);    assert(status);    net_node_t* parentNodePtr = (net_node_t*)vector_at(nodeVectorPtr, fromId);    list_t* childIdListPtr = LocalLoad(&parentNodePtr->childIdListPtr);    status = TMLIST_REMOVE(lock, childIdListPtr, (void*)toId);    assert(status);}

static struct member_data *get_member(struct item_data *data, int index){  if (index < 0 || index >= data->members.size)    return NULL;  struct member_data **member_data = vector_at(&data->members, index);  return *member_data;}

int vector_resize(struct vector_t* v, int makeLower){    int i;    int oldData[v->size];    for(i = 0; i < v->index; i++)    {        oldData[i] = vector_at(*v,i);    }    if(makeLower==0)    {        v->size *= 2;    }    else    {        v->size /= 2;    }    free(v->data);    v->data = (int*) malloc(v->size * sizeof(int));    for(i = 0; i < v->index; i++)    {        v->data[i] = oldData[i];    }    return v->size;}

/** * Resize. */void _hashtable_resize(_hashtable_t* pt_hashtable, size_t t_resize){    size_t        t_tmp = 0;    size_t        t_pos = 0;    size_t        i = 0;    size_t        t_bucketcount = 0;    _hashnode_t*  pt_node = NULL;    _hashnode_t*  pt_nodelist = NULL;    _hashnode_t** ppt_bucket = NULL;    assert(pt_hashtable != NULL);    if(t_resize > _hashtable_bucket_count(pt_hashtable))    {        /* select all element in hash node list */        for(i = 0; i < vector_size(&pt_hashtable->_vec_bucket); ++i)        {            ppt_bucket = (_hashnode_t**)vector_at(&pt_hashtable->_vec_bucket, i);            pt_node = *ppt_bucket;            while(pt_node != NULL)            {                *ppt_bucket = pt_node->_pt_next;                pt_node->_pt_next = pt_nodelist;                pt_nodelist = pt_node;                pt_node = *ppt_bucket;            }        }        /* resize vector bucket */        vector_resize(&pt_hashtable->_vec_bucket, _hashtable_get_prime(t_resize));        t_bucketcount = _hashtable_bucket_count(pt_hashtable);        /* rehash */        while(pt_nodelist != NULL)        {            pt_node = pt_nodelist;            pt_nodelist = pt_node->_pt_next;            t_tmp = _GET_HASHTABLE_TYPE_SIZE(pt_hashtable);            _hashtable_hash_auxiliary(pt_hashtable, pt_node->_pby_data, &t_tmp);            t_pos = t_tmp % t_bucketcount;            ppt_bucket = (_hashnode_t**)vector_at(&pt_hashtable->_vec_bucket, t_pos);            pt_node->_pt_next = *ppt_bucket;            *ppt_bucket = pt_node;        }    }}

void fdset_populate(fdset *fds, fd_set *fset, vector *v) {    int i;    for (i = 0; i < vector_size(v); ++i) {        select_event_t *pse = (select_event_t*)(vector_at(v, i));        FD_SET(pse->fd, fset);        fds->max_fd = (pse->fd > fds->max_fd ? pse->fd : fds->max_fd);    }}

/* ============================================================================= * segments_free * ============================================================================= */voidsegments_free (segments_t* segmentsPtr){    SEQ_FREE(vector_at(segmentsPtr->contentsPtr, 0));    vector_free(segmentsPtr->contentsPtr);    SEQ_FREE(segmentsPtr->strings);    SEQ_FREE(segmentsPtr);}

/** * Access last vector data. */void* vector_back(const vector_t* cpvec_vector){    assert(cpvec_vector != NULL);    assert(_vector_is_inited(cpvec_vector));    assert(!vector_empty(cpvec_vector));    return vector_at(cpvec_vector, vector_size(cpvec_vector) - 1);}

/** * Access first vector data. */void* vector_front(const vector_t* cpvec_vector){    assert(cpvec_vector != NULL);    assert(_vector_is_inited(cpvec_vector));    assert(!vector_empty(cpvec_vector));    return vector_at(cpvec_vector, 0);}

/* ============================================================================= * segments_free * ============================================================================= */voidsegments_free (segments_t* segmentsPtr){    free(vector_at(segmentsPtr->contentsPtr, 0));    vector_free(segmentsPtr->contentsPtr);    free(segmentsPtr->strings);    free(segmentsPtr);}

//获得目标快捷方式指针void find_running_shortcut(){	int find_num=0;  //查找正在作用的桌面图标	for(find_num=0; find_num < app_number; find_num++){		sh_temp_ptr = vector_at(&sh_desktop_vector, find_num);		if(sh_temp_ptr->flag==1)			break;	}}

/* ============================================================================= * net_getChildIdListPtr * ============================================================================= */list_t*net_getChildIdListPtr (net_t* netPtr, long id){    net_node_t* nodePtr = (net_node_t*)vector_at(netPtr->nodeVectorPtr, id);    assert(nodePtr);    return nodePtr->childIdListPtr;}

static void watchfile_destroy(void){  for (int i = 0; i < watchfile_entries.size; ++i) {    struct watchfile_entry *entry = vector_at(&watchfile_entries, i);    free(entry->name);    adex_destroy(&entry->adex);  }  vector_destroy(&watchfile_entries);}

si_t window_manager_get_app_index(struct application_info* ptr){	int i;	i = vector_size(&global_wm.application_info_vector);	while(--i >= 0)		if((int)vector_at(&global_wm.application_info_vector, i) == (int)ptr)			return i;	return -1;}