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_t
net_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 void
tester (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_t
TMnet_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_t
TMnet_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_t
net_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_t
net_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 void
TMremoveEdge (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_t
isCycle (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 void
insertEdge (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_error
sl_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 long
countData (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 void
TMremoveEdge (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
* =============================================================================
*/
void
segments_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
* =============================================================================
*/
void
segments_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;
}
