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;
}
