static void add_record( struct Ordered_container* lib_title, struct Ordered_container* lib_ID )
{
char title [ TITLE_ARRAY_SIZE ];
char medium[ MEDIUM_ARRAY_SIZE ];
struct Record* new_rec;
/* read the record in from the command line */
if ( !get_medium_and_title( medium, title ) )
{
print_error( "Could not read a title!\n" );
return;
}
/* check if the Record already exists */
if ( OC_find_item_arg( lib_title, title , comp_Record_to_title ) != NULL )
{
print_error( "Library already has a record with this title!\n" );
return;
}
else
{
new_rec = create_Record(medium, title );
OC_insert( lib_title, new_rec );
OC_insert( lib_ID, new_rec );
printf( "Record %d added\n", get_Record_ID( new_rec ) );
}
}
int main(void) {
char* topic1 = "Hello";
int time1 = 10;
int room1 = 1001;
struct Meeting* Meeting1 = create_Meeting(time1, topic1);
struct Room* Room1 = create_Room(room1);
printf("%d\n", add_Room_Meeting(Room1, Meeting1)); // 0
printf("%d\n", add_Room_Meeting(Room1, Meeting1)); // -1
print_Meeting(find_Room_Meeting(Room1, time1));
printf("%d\n", remove_Room_Meeting(Room1, Meeting1)); // 0
printf("%d\n", remove_Room_Meeting(Room1, Meeting1)); // -1
printf("%d\n", add_Room_Meeting(Room1, Meeting1)); // 0
clear_Room(Room1);
print_Room(Room1);
const char *topicA = "Whisky", *topicB = "Tango";
const char *firstname1 = "Bo", *lastname1 = "Jackson", *phoneno1 = "123";
const char *firstname2 = "Mike", *lastname2 = "David", *phoneno2 = "456";
struct Person* person1 = create_Person(firstname1, lastname1, phoneno1);
struct Person* person2 = create_Person(firstname2, lastname2, phoneno2);
struct Meeting *new_Meeting1 = create_Meeting(10, topicA);
struct Meeting *new_Meeting2 = create_Meeting(9, topicB);
struct Ordered_container* people = OC_create_container((OC_comp_fp_t) compare_Person_lastname);
OC_insert(people, person1);
OC_insert(people, person2);
struct Room* room2 = create_Room(1000);
add_Meeting_participant(new_Meeting1, person1);
add_Meeting_participant(new_Meeting1, person2);
add_Room_Meeting(room2, new_Meeting1);
add_Room_Meeting(room2, new_Meeting2);
printf("\n...saveload/file...\n");
FILE *fp = fopen("Room_savefile.txt", "w");
save_Room(room2, fp);
fclose(fp);
fp = fopen("Room_savefile.txt", "r");
struct Room *new_Room = load_Room(fp, people);
print_Room(new_Room);
fclose(fp);
}
/* Read room number from stdin and add the room to the room list.
* Print an error message if that person already exist.
*/
void addRoom(struct Ordered_container* rooms) {
int roomNum;
struct Room* room;
if ((roomNum = scanRoomNum()) != -1) {
if (findRoomByNum(rooms, &roomNum)) {
printErrRoomExist();
return;
} else {
room = create_Room(roomNum);
OC_insert(rooms, room);
printf("Room %d added\n", roomNum);
}
}
}
static void add_coll( struct Ordered_container* catalog )
{
struct Collection* new_coll;
char name[ NAME_ARRAY_SIZE ];
read_name( name );
if ( OC_find_item_arg( catalog, name, comp_Collection_to_name ) != NULL )
{
print_error( "Catalog already has a collection with this name!\n" );
return;
}
new_coll = create_Collection( name );
OC_insert( catalog, new_coll );
printf("Collection %s added\n", name );
}
int main(void)
{
//OC_comp_fp_t f_ptr;
struct Ordered_container* container_ptr = OC_create_container(&thing_comp_f);
OC_insert(container_ptr, make_thing(5));
OC_insert(container_ptr, make_thing(3));
OC_insert(container_ptr, make_thing(4));
OC_insert(container_ptr, make_thing(1));
OC_insert(container_ptr, make_thing(2));
OC_insert(container_ptr, make_thing(99));
OC_insert(container_ptr, make_thing(-2));
for (int i = 0; i < 7; ++i)
{
printf("Element %d: %d\n", i, *(int*)(*(container_ptr->array + i)));
}
printf("size = %d\n", OC_get_size(container_ptr));
printf("Empty = %d\n", OC_empty(container_ptr));
int search_num = 5;
int* data_ptr = OC_find_item(container_ptr, &search_num);
printf("Found data: %d\n", *(int*)OC_get_data_ptr(data_ptr));
search_num = 99;
printf("Apply_if_arg returned: %d\n",
OC_apply_if_arg(container_ptr, (OC_apply_if_arg_fp_t)apply_if_arg_tester, &search_num));
data_ptr = OC_find_item_arg(container_ptr, &search_num, alt_thing_comp_f);
printf("Found data: %d\n", *(int*)OC_get_data_ptr(data_ptr));
printf("Things: %d\n", g_num_things);
OC_apply(container_ptr, &delete_thing);
OC_clear(container_ptr);
printf("Things: %d\n", g_num_things);
printf("size = %d\n", OC_get_size(container_ptr));
printf("Empty = %d\n", OC_empty(container_ptr));
OC_destroy_container(container_ptr);
void* test = malloc(8);
printf("Old way %p New Way %p\n", *(void**)test, test);
return 0;
}
int main(void)
{
//OC_comp_fp_t f_ptr;
struct Ordered_container* container_ptr = OC_create_container(&thing_comp_f);
OC_insert(container_ptr, make_thing(5));
OC_insert(container_ptr, make_thing(3));
OC_insert(container_ptr, make_thing(4));
OC_insert(container_ptr, make_thing(1));
OC_insert(container_ptr, make_thing(2));
OC_insert(container_ptr, make_thing(99));
OC_insert(container_ptr, make_thing(-2));
printf("size = %d\n", OC_get_size(container_ptr));
printf("Empty = %d\n", OC_empty(container_ptr));
Print_container(container_ptr, sizeof(int));
int search_num = 5;
int* data_ptr = OC_find_item(container_ptr, &search_num);
printf("Found data: %d\n", *(int*)OC_get_data_ptr(data_ptr));
search_num = 99;
printf("Apply_if_arg returned: %d\n",
OC_apply_if_arg(container_ptr, (OC_apply_if_arg_fp_t)apply_if_arg_tester, &search_num));
data_ptr = OC_find_item_arg(container_ptr, &search_num, alt_thing_comp_f);
printf("Found data: %d\n", *(int*)OC_get_data_ptr(data_ptr));
printf("Things: %d\n", g_num_things);
OC_apply(container_ptr, &delete_thing);
OC_clear(container_ptr);
printf("Things: %d\n", g_num_things);
printf("size = %d\n", OC_get_size(container_ptr));
printf("Empty = %d\n", OC_empty(container_ptr));
Print_container(container_ptr, sizeof(int));
OC_destroy_container(container_ptr);
return 0;
}
int main(void)
{
/* test with some Point objects - the container items hold their addresses, not the actual Point structs! */
/* "brace initialization" is convenient for structure types */
struct Point s1 = {1, 1};
struct Point s2 = {1, 2};
struct Point s3 = {2, 1};
struct Point s4 = {2, 2};
struct Point probe1 = {1, 2};
struct Point probe2 = {99, 99};
struct Ordered_container * container;
container = OC_create_container(compare_Points);
printf("size is %d\n", OC_get_size(container));
OC_apply(container, print_as_Point);
/* fill the container with s1, s2, s3, s4 but insert in this order: s3, s1, s4, s2,
and see if the points get put in the right order. */
printf("\ninserting (%d, %d)\n", s3.x, s3.y);
OC_insert(container, &s3);
printf("size is %d\n", OC_get_size(container));
OC_apply(container,print_as_Point);
printf("\ninserting (%d, %d)\n", s1.x, s1.y);
OC_insert(container, &s1);
printf("size is %d\n",OC_get_size(container));
OC_apply(container, print_as_Point);
printf("\ninserting (%d, %d)\n", s4.x, s4.y);
OC_insert(container, &s4);
printf("size is %d\n", OC_get_size(container));
OC_apply(container, print_as_Point);
printf("\ninserting (%d, %d)\n", s2.x, s2.y);
OC_insert(container, &s2);
printf("size is %d\n", OC_get_size(container));
OC_apply(container, print_as_Point);
/* use find_item and delete_item */
find_and_remove(container, probe1);
printf("size is %d\n", OC_get_size(container));
OC_apply(container, print_as_Point);
find_and_remove(container, probe2);
printf("size is %d\n", OC_get_size(container));
OC_apply(container, print_as_Point);
/* demo another apply function - note function pointer cast is not needed for this one */
{
int odd_or_even_value = 42;
OC_apply_arg(container, demo_func, (void *)&odd_or_even_value);
odd_or_even_value = 3;
OC_apply_arg(container, demo_func, (void *)&odd_or_even_value);
}
OC_clear(container);
printf("size is %d\n", OC_get_size(container));
OC_apply(container, print_as_Point);
OC_destroy_container(container);
/* using the pointer "container" is undefined at this point */
printf("Done\n");
return 0;
}
int main( void )
{
int i;
int cur_size_container = 0;
char* test_string[] = { "t5", "t6", "t3", "t9", "t7", "t1", "t2" };
int size_test = 7;
char* s1 = "s1";
/*char* s2 = "s2";
char* s3 = "s3";
char* s4 = "s4";
char* s5 = "s5";
char* s6 = "s6";
char* probe1 = "s3";
char* probe2 = "s99";
char* probe3 = "t2";
char* probe4 = "t11";*/
void* node;
struct Ordered_container * container;
printf("Starting test\nCreating\n" );
/* create the container */
container = OC_create_container((int (*)(const void*, const void*))compare_string);
for ( i = 0 ; i < size_test ; ++i )
{
printf("Inserting %s\n", test_string[ i ] );
OC_insert( container, test_string[ i ] );
cur_size_container = OC_get_size( container );
printf("\tsize is %d\n", cur_size_container );
/* make sure it has the correct size */
assert( ( i + 1 ) == cur_size_container );
if ( /*( i % 3 ) == 1 */ 1 )
{
OC_apply( container, (void (*)(void*))print_as_string) ;
}
}
assert( OC_apply_if( container, (int (*)(void*))right_form ) == 0 );
printf( "Inserting s1\n " );
OC_insert( container, s1 );
OC_apply( container, (void (*)(void*))print_as_string) ;
assert( OC_apply_if( container, (int (*)(void*))right_form ) == ('s' - 't' ) );
node = OC_find_item( container, s1 );
OC_apply( container, (void (*)(void*))print_as_string) ;
/* check the correct pointer is returned */
printf( "\nAfter adding s1\n" );
assert( OC_get_data_ptr( node ) == s1 );
/* check to make sure delete is working */
OC_delete_item( container, node );
assert( OC_get_size( container ) == size_test );
/* check clear function */
OC_clear( container );
assert( OC_empty( container ) != 0 );
/* rebuild array to run more tests */
for ( i = 0 ; i < size_test ; ++i )
{
OC_insert( container, test_string[ i ] );
cur_size_container = OC_get_size( container );
/* make sure it has the correct size */
assert( ( i + 1 ) == cur_size_container );
}
/* removing one element at a time */
for( i = 0 ; i < size_test ; ++i )
{
printf( "%d: removing %s\n", i , test_string[i] );
OC_apply( container, (void (*)(void*))print_as_string) ;
find_and_remove( container, test_string[i] );
assert( ( size_test - i - 1 ) == OC_get_size( container ) );
}
/* clean up memory */
/* run with valgrind to ensure no mem leaks */
OC_destroy_container( container );
return 0;
}
int main(int argc, const char * argv[]) {
int a = 1, b = 3, c = 5, d = 7,
e = 2, f = 4, g = 6, h = 8;
void *ptr1 = &a, *ptr2 = &b, *ptr3 = &c, *ptr4 = &d,
*ptr5 = &e, *ptr6 = &f, *ptr7 = &g, *ptr8 = &h;
struct Ordered_container* container1 = OC_create_container( (OC_comp_fp_t)compare_int_ptr);
assert(container1);
OC_insert(container1, ptr3);
print_containter(container1); // 5
OC_insert(container1, ptr2);
print_containter(container1); // 3 5
OC_insert(container1, ptr6); // 4
print_containter(container1); // 3 4 5
OC_insert(container1, ptr4);
print_containter(container1); // 3 4 5 7
OC_insert(container1, ptr1);
print_containter(container1); // 1 3 4 5 7
OC_insert(container1, ptr8);
print_containter(container1); // 1 3 4 5 7 8
printf("%d\n",OC_get_size(container1)); // 6
printf("%d\n",OC_empty(container1)); // 0
OC_clear(container1);
printf("%d\n",OC_get_size(container1));
OC_insert(container1, ptr3);
print_containter(container1); // 5
OC_insert(container1, ptr2);
print_containter(container1); // 3 5
OC_insert(container1, ptr4);
print_containter(container1); // 3 5 7
OC_insert(container1, ptr1);
print_containter(container1); // 1 3 5 7
OC_insert(container1, ptr8);
print_containter(container1); // 1 3 5 7 8
//OC_destroy_container(container1);
void* found_item_ptr1 = OC_find_item(container1, ptr4);
if (!found_item_ptr1) {
printf("found_item_ptr not found");
} else {
printf("found_item_ptr");
printf(" and it's %d\n", *(int*)OC_get_data_ptr(found_item_ptr1));
}
OC_delete_item(container1, found_item_ptr1);
print_containter(container1); // 1 3 5 8
void* found_item_ptr2 = OC_find_item(container1, ptr1);
OC_delete_item(container1, found_item_ptr2);
void* found_item_ptr3 = OC_find_item(container1, ptr8);
OC_delete_item(container1, found_item_ptr3);
print_containter(container1); // 3 5
OC_insert(container1, ptr6); // 4
print_containter(container1); // 3 4 5
OC_insert(container1, ptr5); // 2
print_containter(container1); // 2 3 4 5
printf("%d\n",OC_get_size(container1)); // 4
OC_apply(container1, (OC_apply_fp_t)print_int); // 2 3 4 5
printf("\n");
return 0;
}
static void load_from_file( struct Ordered_container* lib_title, struct Ordered_container* lib_ID, struct Ordered_container* catalog )
{
FILE* in_file = read_open_file( "r" );
if ( in_file )
{
int i, num;
clear_all( lib_title, lib_ID, catalog, "" );
/* read in the number of Records to load */
if( fscanf( in_file, "%d", &num ) != 1 )
{
clear_all( lib_title, lib_ID, catalog, "" );
print_error( "Invalid data found in file!\n" );
return ;
}
/* load the data */
for ( i = 0; i < num; ++i )
{
struct Record* rec = load_Record( in_file );
if ( rec )
{
/* if record was loaded correctly insert it */
OC_insert( lib_ID, rec );
OC_insert( lib_title, rec);
}
else
{
clear_all( lib_title, lib_ID, catalog, "" );
print_error( "Invalid data found in file!\n" );
return;
}
}
/* read in the number of things to load */
if( fscanf( in_file, "%d", &num ) != 1 )
{
clear_all( lib_title, lib_ID, catalog, "" );
print_error( "Invalid data found in file!\n" );
return ;
}
/* load the data in from the file */
for ( i = 0 ; i < num ; ++i )
{
struct Collection* coll = load_Collection( in_file, lib_title );
if ( coll )
OC_insert( catalog, coll );
else
{
clear_all( lib_title, lib_ID, catalog, "" );
print_error( "Invalid data found in file!\n" );
return;
}
}
printf( "Data loaded\n" );
fclose( in_file );
}
}
