void sip_list_sorter(vector_t *vector, void *item) { sip_call_t *prev, *cur = (sip_call_t *)item; int count = vector_count(vector); int i; // First item is alway sorted if (vector_count(vector) == 1) return; prev = vector_item(vector, vector_count(vector) - 2); // Check if the item is already sorted if (call_attr_compare(cur, prev, calls.sort.by) == 0) { return; } for (i = count - 2 ; i >= 0; i--) { // Get previous item prev = vector_item(vector, i); // Check if the item is already in a sorted position int cmp = call_attr_compare(cur, prev, calls.sort.by); if ((calls.sort.asc && cmp > 0) || (!calls.sort.asc && cmp < 0)) { vector_insert(vector, item, i + 1); return; } } // Put this item at the begining of the vector vector_insert(vector, item, 0); }
template<class KEY, class VALUE> Nde* Nde::merge_right (int parent_index_this) { // copy elements from the right sibling into this node, along with the // element in the parent node vector that has the right sibling as it subtree. // the right sibling and that parent element are then deleted Elem parent_elem = (*mp_parent)[parent_index_this+1]; Nde* right_sib = (*mp_parent)[parent_index_this+1].mp_subtree; parent_elem.mp_subtree = (*right_sib)[0].mp_subtree; vector_insert (parent_elem); for (unsigned int i=1; i<right_sib->m_count; i++) vector_insert ((*right_sib)[i]); mp_parent->vector_delete (parent_index_this+1); delete right_sib; if (mp_parent==find_root() && !mp_parent->key_count()) { m_root.set_root(m_root.get_root(), this); delete mp_parent; mp_parent = 0; return null_ptr; } else if (mp_parent==find_root() && mp_parent->key_count()) return null_ptr; if (mp_parent&& mp_parent->key_count() >= mp_parent->minimum_keys()) return null_ptr; // no need for parent to import an element return mp_parent; // parent must import an element }
void capture_packet_time_sorter(vector_t *vector, void *item) { capture_packet_t *prev, *cur; int count = vector_count(vector); int i; // Get current item cur = (capture_packet_t *) item; prev = vector_item(vector, count - 2); // Check if the item is already sorted if (prev && timeval_is_older(cur->header->ts, prev->header->ts)) { return; } for (i = count - 2 ; i >= 0; i--) { // Get previous packet prev = vector_item(vector, i); // Check if the item is already in a sorted position if (timeval_is_older(cur->header->ts, prev->header->ts)) { vector_insert(vector, item, i + 1); return; } } // Put this item at the begining of the vector vector_insert(vector, item, 0); }
int merge_left (PBTREE btree, int node_idx, int parent_index_this) { // copy all elements from this node into the left sibling, along with the // element in the parent node vector that has this node as its subtree. // this node and its parent element are then deleted. int i; int parent_node_idx = btree->nodes[node_idx].parent_node_idx; BTREE_ELEMENT parent_elem; memcpy(&parent_elem, &btree->nodes[parent_node_idx].elements[parent_index_this], sizeof(BTREE_ELEMENT)); int left_sib = btree->nodes[parent_node_idx].elements[parent_index_this-1].subtree_node_idx; parent_elem.subtree_node_idx = btree->nodes[node_idx].elements[0].subtree_node_idx; vector_insert (btree, left_sib, &parent_elem); for (i=1; i<btree->nodes[node_idx].element_count; i++) vector_insert (btree, left_sib, &btree->nodes[node_idx].elements[i]); vector_delete_pos (btree, parent_node_idx, parent_index_this); if (parent_node_idx==find_root(btree) && !key_count(btree, parent_node_idx)) { set_root(btree, left_sib); delete_node(btree, parent_node_idx); btree->nodes[left_sib].parent_node_idx = BTREE_INVALID_NODE_IDX; delete_node(btree, node_idx); return BTREE_INVALID_NODE_IDX; } else if (parent_node_idx==find_root(btree) && key_count(btree, parent_node_idx)) { delete_node(btree, node_idx); return BTREE_INVALID_NODE_IDX; } delete_node(btree, node_idx); if (key_count(btree, parent_node_idx) >= btree_minimum_keys()) return BTREE_INVALID_NODE_IDX; // no need for parent to import an element return parent_node_idx; // parent must import an element }
void capture_packet_time_sorter(vector_t *vector, void *item) { struct timeval curts, prevts; int count = vector_count(vector); int i; // TODO Implement multiframe packets curts = packet_time(item); prevts = packet_time(vector_last(vector)); // Check if the item is already sorted if (timeval_is_older(curts, prevts)) { return; } for (i = count - 2 ; i >= 0; i--) { // Get previous packet prevts = packet_time(vector_item(vector, i)); // Check if the item is already in a sorted position if (timeval_is_older(curts, prevts)) { vector_insert(vector, item, i + 1); return; } } // Put this item at the begining of the vector vector_insert(vector, item, 0); }
/* * Unit test for the vector_insert function. Runs some example * operations and checks that results are as expected, writing * messages to the terminal so that errors can be detected and * pinpointed. * * \return zero on success. */ int test_insert (void) { static int const check[] = { 102, 101, 209, 208, 207, 206, 205, 204, 203, 100, 99, 98, 97 }; static unsigned long const checklen = sizeof(check) / sizeof(*check); Vector vec; int ii; printf ("\nrunning test_insert...\n"); vector_init (&vec); printf ("initialized: "); vector_dump (&vec); if (0 == vector_insert(&vec, 11, 42)) { printf ("test_insert ERROR: should not have been able to insert at invalid index\n"); vector_destroy (&vec); return -1; } for (ii = -3; ii < 3; ++ii) { if (0 != vector_insert (&vec, 0, 100+ii)) { printf ("test_insert ERROR: could not insert %d at pos 0\n", 100+ii); vector_destroy (&vec); return -1; } printf ("inserted %3d at pos 0: ", 100+ii); vector_dump (&vec); } for (; ii < 10; ++ii) { if (0 != vector_insert (&vec, 2, 200+ii)) { printf ("test_insert ERROR: could not insert %d at pos 2\n", 200+ii); vector_destroy (&vec); return -1; } printf ("inserted %3d at pos 2: ", 200+ii); vector_dump (&vec); } if (checklen != vec.len) { printf ("test_insert ERROR: vector length should be %lu but is %lu\n", checklen, vec.len); vector_destroy (&vec); return -2; } for (ii = 0; ii < checklen; ++ii) if (vec.arr[ii] != check[ii]) { printf ("test_insert ERROR: arr[%d] should be %d but is %d\n", ii, check[ii], vec.arr[ii]); vector_destroy (&vec); return -1; } printf ("test_insert SUCCESS\n"); vector_destroy (&vec); return 0; }
int split_insert (PBTREE btree, int node_idx, PBTREE_ELEMENT element) { int i; int split_point; int new_node_idx; BTREE_ELEMENT upward_element; // split_insert should only be called if node is full if (btree->nodes[node_idx].element_count != BTREE_MAX_ELEMENTS-1) return 0; vector_insert_for_split (btree, node_idx, element); split_point = btree->nodes[node_idx].element_count/2; if (2*split_point < btree->nodes[node_idx].element_count) // perform the "ceiling function" split_point++; // new node receives the rightmost half of elements in *this node new_node_idx = get_free_node(btree); if (!BTREE_IS_VALID_NODE_IDX(new_node_idx)) return 0; memcpy(&upward_element, &btree->nodes[node_idx].elements[split_point], sizeof(BTREE_ELEMENT)); insert_zeroth_subtree (btree, new_node_idx, upward_element.subtree_node_idx); upward_element.subtree_node_idx = new_node_idx; // element that gets added to the parent of this node for (i=1; i<btree->nodes[node_idx].element_count-split_point; i++) vector_insert(btree, new_node_idx, &btree->nodes[node_idx].elements[split_point+i]); btree->nodes[new_node_idx].element_count = btree->nodes[node_idx].element_count-split_point; btree->nodes[node_idx].element_count = split_point; btree->nodes[new_node_idx].parent_node_idx = btree->nodes[node_idx].parent_node_idx; // now insert the new node into the parent, splitting it if necessary if (BTREE_IS_VALID_NODE_IDX(btree->nodes[node_idx].parent_node_idx) && vector_insert(btree, btree->nodes[node_idx].parent_node_idx, &upward_element)) return 1; else if (BTREE_IS_VALID_NODE_IDX(btree->nodes[node_idx].parent_node_idx) && split_insert(btree, btree->nodes[node_idx].parent_node_idx, &upward_element)) return 1; else if (!BTREE_IS_VALID_NODE_IDX(btree->nodes[node_idx].parent_node_idx)) { // this node was the root int new_root = get_free_node(btree); insert_zeroth_subtree(btree, new_root, node_idx); btree->nodes[node_idx].parent_node_idx = new_root; btree->nodes[new_node_idx].parent_node_idx = new_root; vector_insert (btree, new_root, &upward_element); btree->root_node_idx = new_root; btree->nodes[new_root].parent_node_idx = BTREE_INVALID_NODE_IDX; } return 1; }
// ---------------------------------------------------------------------------- size_t vertex_buffer_insert( vertex_buffer_t * self, size_t index, void * vertices, size_t vcount, GLuint * indices, size_t icount ) { assert( self ); assert( vertices ); assert( indices ); self->state = FROZEN; // Push back vertices size_t vstart = vector_size( self->vertices ); vertex_buffer_push_back_vertices( self, vertices, vcount ); // Push back indices size_t istart = vector_size( self->indices ); vertex_buffer_push_back_indices( self, indices, icount ); // Update indices within the vertex buffer size_t i; for( i=0; i<icount; ++i ) { *(GLuint *)(vector_get( self->indices, istart+i )) += vstart; } // Insert item ivec4 item = {{ vstart, vcount, istart, icount }}; vector_insert( self->items, index, &item ); self->state = DIRTY; return index; }
/* This currently *only* works for client call requests. * We need to do something else to allocate calls for incoming requests. */ PPTP_CALL * pptp_call_open(PPTP_CONN * conn, pptp_call_cb callback, char *phonenr) { PPTP_CALL * call; int i; int idx, rc; /* Send off the call request */ struct pptp_out_call_rqst packet = { PPTP_HEADER_CTRL(PPTP_OUT_CALL_RQST), 0,0, /*call_id, sernum */ hton32(PPTP_BPS_MIN), hton32(PPTP_BPS_MAX), hton32(PPTP_BEARER_CAP), hton32(PPTP_FRAME_CAP), hton16(PPTP_WINDOW), 0, 0, 0, {0}, {0} }; assert(conn && conn->call); assert(conn->conn_state == CONN_ESTABLISHED); /* Assign call id */ if (!vector_scan(conn->call, 0, PPTP_MAX_CHANNELS - 1, &i)) /* no more calls available! */ return NULL; /* allocate structure. */ if ((call = malloc(sizeof(*call))) == NULL) return NULL; /* Initialize call structure */ call->call_type = PPTP_CALL_PNS; call->state.pns = PNS_IDLE; call->call_id = (u_int16_t) i; call->sernum = conn->call_serial_number++; call->callback = callback; call->closure = NULL; packet.call_id = htons(call->call_id); packet.call_sernum = htons(call->sernum); /* if we have a quirk, build a new packet to fit it */ idx = get_quirk_index(); if (idx != -1 && pptp_fixups[idx].out_call_rqst_hook) { if ((rc = pptp_fixups[idx].out_call_rqst_hook(&packet))) warn("calling the out_call_rqst hook failed (%d)", rc); } /* fill in the phone number if it was specified */ if (phonenr) { strncpy((char *)packet.phone_num, phonenr, sizeof(packet.phone_num)); packet.phone_len = strlen(phonenr); if( packet.phone_len > sizeof(packet.phone_num)) packet.phone_len = sizeof(packet.phone_num); packet.phone_len = hton16 (packet.phone_len); } if (pptp_send_ctrl_packet(conn, &packet, sizeof(packet))) { pptp_reset_timer(); call->state.pns = PNS_WAIT_REPLY; /* and add it to the call vector */ vector_insert(conn->call, i, call); return call; } else { /* oops, unsuccessful. Deallocate. */ free(call); return NULL; } }
void test_vector_insert() { array *arr = vector_create(); vector_append(arr, 5); vector_append(arr, 4); vector_append(arr, 3); vector_insert(arr, 100, 2); ASSERT(arr->array[2] == 100); vector_free(arr); }
END_TEST START_TEST (insert_fails_if_position_bigger_than_length_or_negative) { int num = 10; int rc; vector *v = vector_new(sizeof(int *), NULL, 5); rc = vector_insert(v, &num, 4); /* bigger than logical length */ fail_unless(rc == VECT_INSERT_INVALID_POSITION); fail_unless(vector_length(v) == 0); rc = vector_insert(v, &num, -2); fail_unless(rc == VECT_INSERT_INVALID_POSITION); fail_unless(vector_length(v) == 0); vector_free(v); }
int vector_fill(Vector *v) { // if (!v) // return ERROR_NULL_VECTOR; srand(time(0)); unsigned int i; for(i = 0; i < v->capacity; i++) vector_insert(v, rand() % (v->capacity*10)); return OK; }
int main(int argc, char** argv) { if (argc < 2) { helper(); return PARAM_E; } int i; Vector *v = vector_create(2); if (v == NULL) { return MEMORY_E; } for (i = 1; i < argc; i++) { switch (argv[i][0]) { case 'f': printe(v, vector_find(v, atoi(argv[++i]))); break; case 'c': printf("%d\n", vector_count(v, atoi(argv[++i]))); break; case 'e': printe(v, atoi(argv[++i])); break; case 'p': if (!strcmp(argv[i], "print")) { printv(v); } break; case 's': vector_sort(v, atoi(argv[++i])); break; case '-': vector_remove(v, -atoi(argv[i])); break; default: vector_insert(v, atoi(argv[i]), atoi(argv[i+1])); i++; break; } } vector_destroy(v); return SUCCESS; }
END_TEST START_TEST (insert_should_grow_if_needed) { int num1 = 1, num2 = 2, num3 = 3, num4 = 4; vector *v = vector_new(sizeof(int *), NULL, 2); fail_unless(vector_insert(v, &num4, 0) == 0); fail_unless(vector_insert(v, &num3, 0) == 0); fail_unless(vector_insert(v, &num2, 0) == 0); /* grow before insert */ fail_unless(vector_insert(v, &num1, 0) == 0); fail_unless(4 == vector_length(v)); fail_unless(1 == *(int *)vector_get(v, 0)); fail_unless(2 == *(int *)vector_get(v, 1)); fail_unless(3 == *(int *)vector_get(v, 2)); fail_unless(4 == *(int *)vector_get(v, 3)); vector_free(v); }
/** Dodaje węzłowi syna, do którego prowadzi krawędź z literą c @param[in,out] node Węzeł @param[in] c Litera @return Wskaźnik na syna */ static trie_node * node_add_son(trie_node *node, const wchar_t c) { assert(node_son(node, c) == NULL); trie_node *son = node_make_leaf(c); int size = vector_size(node->sons); int index = 0; if(size > 0 && NTH_SON_CHAR(node, size - 1) < c) index = size; while(index < size && NTH_SON_CHAR(node, index) < c) index++; vector_insert(node->sons, &son, index); return son; }
int main(int argc, char **argv) { int *a, *b, *c, *d, *e, *f, *g; a = (int *)malloc(sizeof(int)); b = (int *)malloc(sizeof(int)); c = (int *)malloc(sizeof(int)); d = (int *)malloc(sizeof(int)); e = (int *)malloc(sizeof(int)); f = (int *)malloc(sizeof(int)); g = (int *)malloc(sizeof(int)); *a = 6; *b = 1; *c = 99; *d = -17; *e = 22; *f = 9; *g = 6; struct Vector *iv = create_vector(2, free); vector_push_back(iv, a); vector_push_back(iv, b); vector_push_back(iv, c); vector_push_back(iv, d); vector_push_front(iv, e); vector_push_front(iv, f); vector_insert(iv, g, 5); vector_foreach(iv, print); printf("\nCount: %d, Capacity: %d--------------\n", vector_count(iv), vector_capacity(iv)); printf("%d\n", *f); vector_remove(iv, f, compare, TRUE); vector_foreach(iv, print); printf("\nCount: %d, Capacity: %d--------------\n", vector_count(iv), vector_capacity(iv)); vector_sort(iv, compare); vector_foreach(iv, print); printf("\nCount: %d, Capacity: %d--------------\n", vector_count(iv), vector_capacity(iv)); printf("\nBsearch: %d, Lower: %d, Upper: %d\n", vector_bsearch(iv, a, compare), vector_lower(iv, a, compare), vector_upper(iv, a, compare)); vector_shuffle(iv); vector_foreach(iv, print); printf("\nCount: %d, Capacity: %d--------------\n", vector_count(iv), vector_capacity(iv)); destroy_vector(iv, TRUE); }
char *test_insert_at_end() { vector_p vector = vector_create(sizeof(int)); vector_add(vector, test_data(0)); vector_add(vector, test_data(1)); int did_insert = vector_insert(vector, 2, test_data(2)); mu_assert(vector->length == 3, "should have a length of 3"); mu_assert(did_insert, "should have inserted"); mu_assert(*(int*)vector_get(vector, 2) == 2, "should have added item at end"); vector_free(vector); return NULL; }
END_TEST START_TEST (insert_elements_in_all_positions) { char *move1 = strdup("forward loop"); char *move2 = strdup("goiter"); char *move3 = strdup("flaka"); char *move4 = strdup("back loop"); vector *v = vector_new(sizeof(char *), free_string, 5); fail_if(vector_insert(v, &move1, 0) == -1); fail_if(vector_insert(v, &move4, 1) == -1); fail_if(vector_insert(v, &move2, 1) == -1); fail_if(vector_insert(v, &move3, 2) == -1); fail_unless(4 == vector_length(v)); fail_unless(move1 == *(char **)vector_get(v, 0)); fail_unless(move2 == *(char **)vector_get(v, 1)); fail_unless(move3 == *(char **)vector_get(v, 2)); fail_unless(move4 == *(char **)vector_get(v, 3)); vector_free(v); }
char *test_insert_at_beginning() { vector_p vector = vector_create(sizeof(int)); vector_add(vector, test_data(1)); int did_insert = vector_insert(vector, 0, test_data(0)); mu_assert(vector->length == 2, "should have a length of 2"); mu_assert(did_insert, "should have inserted"); mu_assert(*(int*)vector_get(vector, 0) == 0, "should have added item at start"); mu_assert(*(int*)vector_get(vector, 1) == 1, "should have moved other items"); vector_free(vector); return NULL; }
template<class KEY, class VALUE> Nde* Nde::rotate_from_right(int parent_index_this) { // new element to be added to this node Elem underflow_filler = (*mp_parent)[parent_index_this+1]; // right sibling of this node Nde* right_sib = (*mp_parent)[parent_index_this+1].mp_subtree; underflow_filler.mp_subtree = (*right_sib)[0].mp_subtree; // copy the entire element (*mp_parent)[parent_index_this+1] = (*right_sib)[1]; // now restore correct pointer (*mp_parent)[parent_index_this+1].mp_subtree = right_sib; vector_insert (underflow_filler); right_sib->vector_delete(0); (*right_sib)[0].m_key = ""; (*right_sib)[0].m_payload = ""; return null_ptr; // parent node still has same element count }
template<class KEY, class VALUE> Nde* Nde::rotate_from_left(int parent_index_this) { // new element to be added to this node Elem underflow_filler = (*mp_parent)[parent_index_this]; // left sibling of this node Nde* left_sib = (*mp_parent)[parent_index_this-1].mp_subtree; underflow_filler.mp_subtree = (*this)[0].mp_subtree; (*this)[0].mp_subtree = (*left_sib)[left_sib->m_count-1].mp_subtree; if ((*this)[0].mp_subtree) (*this)[0].mp_subtree->mp_parent = this; // copy the entire element (*mp_parent)[parent_index_this] = (*left_sib)[left_sib->m_count-1]; // now restore correct pointer (*mp_parent)[parent_index_this].mp_subtree = this; vector_insert (underflow_filler); left_sib->vector_delete(left_sib->m_count-1); return null_ptr; // parent node still has same element count }
void test_vector() { size_t arr[10], arr2[10]; size_t i, j; vector vec; j = 200; vector_init(&vec, &malloc, &free); for (i = 0; i < 10; ++i) { arr[i] = i; vector_push_back(&vec, &arr[i]); } for (i = 0; i < 10; ++i) { arr2[i] = i + 10; vector_push_back(&vec, &arr2[i]); } vector_insert(&vec, &j, vec.size); vector_remove(&vec, 0); printf("-----\nVector testing\n-----\nSize: %d\nMax size: %d\nContents: ", vector_size(&vec), vector_max_size(&vec)); for (i = 0; i < 20; ++i) printf("%d ", *(size_t*)vector_pop_back(&vec)); vector_push_back(&vec, &j); printf("\nFront: %d\nBack: %d\n", *(size_t*)vector_front(&vec), *(size_t*)vector_back(&vec)); vector_clear(&vec); printf("Vector cleared\nSize: %d\n", vec.size); vector_free(&vec); printf("\n"); }
int heap_move_roots_to_vector(Vector *h, Vector *v) { // if (!h || !v) // return ERROR_NULL_VECTOR; // if(!h->size) // return ERROR_EMPTY_VECTOR; int max; int i; int heap_pre_size = h->size; for (i = 0; i < heap_pre_size; i++) { max = heap_remove_max(h); vector_insert(v, max); } _vector_revert(v); return OK; }
int rotate_from_right(PBTREE btree, int node_idx, int parent_index_this) { int parent_node_idx = btree->nodes[node_idx].parent_node_idx; // new element to be added to this node BTREE_ELEMENT underflow_filler; memcpy(&underflow_filler, &btree->nodes[parent_node_idx].elements[parent_index_this+1], sizeof(BTREE_ELEMENT)); // right sibling of this node int right_sib = btree->nodes[parent_node_idx].elements[parent_index_this+1].subtree_node_idx; underflow_filler.subtree_node_idx = btree->nodes[right_sib].elements[0].subtree_node_idx; // copy the entire element memcpy(&btree->nodes[parent_node_idx].elements[parent_index_this+1], &btree->nodes[right_sib].elements[1], sizeof(BTREE_ELEMENT)); // now restore correct pointer btree->nodes[parent_node_idx].elements[parent_index_this+1].subtree_node_idx = right_sib; vector_insert (btree, node_idx, &underflow_filler); vector_delete_pos(btree, right_sib, 0); btree->nodes[right_sib].elements[0].key = btree->invalid_key; btree->nodes[right_sib].elements[0].data_entry_idx = BTREE_INVALID_ENTRY_IDX; return BTREE_INVALID_NODE_IDX; // parent node still has same element count }
static int add_member(struct item_data *data, uint32_t address, enum watch_type type, int position, _Bool anchored, int x, int y, _Bool position_set) { if (data->members.size >= SETTINGS_WATCHES_MAX || position < 0 || position > data->members.size) return 0; ++data->add_button->y; #ifndef WIIVC ++data->import_button->y; #endif for (int i = position; i < data->members.size; ++i) { struct member_data *member_data = get_member(data, i); ++member_data->index; ++member_data->member->y; } struct menu *imenu; struct member_data *member_data = malloc(sizeof(*member_data)); member_data->data = data; member_data->index = position; member_data->member = menu_add_imenu(data->imenu, 0, position, &imenu); member_data->anchor_button = menu_item_add(imenu, 2, 0, NULL, 0xFFFFFF); member_data->anchor_button->enter_proc = anchor_button_enter_proc; member_data->anchor_button->draw_proc = anchor_button_draw_proc; member_data->anchor_button->activate_proc = anchor_button_activate_proc; member_data->anchor_button->data = member_data; member_data->positioning = menu_add_positioning(imenu, 4, 0, position_proc, member_data); member_data->userwatch = menu_add_userwatch(imenu, 6, 0, address, type); member_data->anchored = 1; member_data->anchor_anim_state = 0; member_data->x = x; member_data->y = y; member_data->position_set = 1; menu_add_button_icon(imenu, 0, 0, list_icons, 1, 0xFF0000, remove_button_proc, member_data); if (anchored) menu_item_disable(member_data->positioning); else release_member(member_data); member_data->position_set = position_set; vector_insert(&data->members, position, 1, &member_data); return 1; }
int rotate_from_left(PBTREE btree, int node_idx, int parent_index_this) { int parent_node_idx = btree->nodes[node_idx].parent_node_idx; // new element to be added to this node BTREE_ELEMENT underflow_filler; memcpy(&underflow_filler, &btree->nodes[parent_node_idx].elements[parent_index_this], sizeof(BTREE_ELEMENT)); // left sibling of this node int left_sib = btree->nodes[parent_node_idx].elements[parent_index_this-1].subtree_node_idx; underflow_filler.subtree_node_idx = btree->nodes[left_sib].elements[0].subtree_node_idx; btree->nodes[node_idx].elements[0].subtree_node_idx = btree->nodes[left_sib].elements[btree->nodes[left_sib].element_count-1].subtree_node_idx; if (BTREE_IS_VALID_NODE_IDX(btree->nodes[node_idx].elements[0].subtree_node_idx)) btree->nodes[btree->nodes[node_idx].elements[0].subtree_node_idx].parent_node_idx = node_idx; // copy the entire element memcpy(&btree->nodes[parent_node_idx].elements[parent_index_this], &btree->nodes[left_sib].elements[btree->nodes[left_sib].element_count-1], sizeof(BTREE_ELEMENT)); // now restore correct pointer btree->nodes[parent_node_idx].elements[parent_index_this].subtree_node_idx = node_idx; vector_insert (btree, node_idx, &underflow_filler); vector_delete_pos(btree, left_sib, btree->nodes[left_sib].element_count-1); return BTREE_INVALID_NODE_IDX; // parent node still has same element count }
hale_internal inline Buf * allocate_buffers(FixedGapArena *arena, memi at, memi count) { vector_insert(&arena->buffers, at, count); Buf *buffer = &arena->buffers[at]; Buf *buffer_end = buffer + count; ch8 *memory = (ch8*)platform.allocate_paged_memory(buf_capacity * count); while (buffer != buffer_end) { buffer->gap_start = memory; buffer->gap_end = memory + buf_capacity; hale_debug(buffer->debug_page = memory); hale_debug(buffer->debug_length = 0); requirement_check_buf(buffer); ++buffer; memory += buf_capacity; } return buffer - count; }
int btree_insert (PBTREE btree, PBTREE_ELEMENT element) { int last_visited_node_idx; if (!BTREE_IS_VALID_NODE_IDX(btree->root_node_idx)) { int node_idx = get_free_node(btree); if (!BTREE_IS_VALID_NODE_IDX(node_idx)) return 0; else { set_root(btree, node_idx); insert_zeroth_subtree (btree, node_idx, BTREE_INVALID_NODE_IDX); } } last_visited_node_idx = btree->root_node_idx; if (btree_search_ex(btree, &last_visited_node_idx, element->key)) // element already in tree return 0; if (vector_insert(btree, last_visited_node_idx, element)) return 1; return split_insert(btree, last_visited_node_idx, element); }
END_TEST START_TEST (insert_element_in_the_beginning) { char *py = strdup("python"); char *rb = strdup("ruby"); char *lp = strdup("lisp"); int rc; vector *v = vector_new(sizeof(char *), free_string, 5); vector_append(v, &py); vector_append(v, &rb); rc = vector_insert(v, &lp, 0); fail_unless(rc == 0); fail_unless(vector_length(v) == 3); fail_unless(lp == *(char **)vector_get(v, 0)); fail_unless(py == *(char **)vector_get(v, 1)); fail_unless(rb == *(char **)vector_get(v, 2)); vector_free(v); }
// ---------------------------------------------------------------------------- size_t vertex_buffer_insert( vertex_buffer_t * self, const size_t index, const void * vertices, const size_t vcount, const GLuint * indices, const size_t icount ) { size_t vstart, istart, i; ivec4 item; assert( self ); assert( vertices ); assert( indices ); self->state = FROZEN; // Push back vertices vstart = vector_size( self->vertices ); vertex_buffer_push_back_vertices( self, vertices, vcount ); // Push back indices istart = vector_size( self->indices ); vertex_buffer_push_back_indices( self, indices, icount ); // Update indices within the vertex buffer for( i=0; i<icount; ++i ) { *(GLuint *)(vector_get( self->indices, istart+i )) += vstart; } // Insert item item.x = vstart; item.y = vcount; item.z = istart; item.w = icount; vector_insert( self->items, index, &item ); self->state = DIRTY; return index; }