Description
Construct a double-linked list package.
Use the double-linked list to implement a guitar database
The guitar record itself is a datatype with its own header file.
The user interface of the main program (lab2.c) should be extended to include the
following commands:
ADD, DELETE, LOOKUP, FIRST, LAST, NEXT, PREV, LIST, HELP, QUIT
The program should FIRST read one of these commands from the command line,
and THEN prompt the user for any required arguments one at a time. The program
should store the guitars in the list in order sorted on the id number (key)
/*————————-*/
/* guitar.h */
#if 0
The guitardb_guitar should now be a first class ADT, including a compare function
for use in “insert_after,” “find” and “remove.” Return 0 or non-NULL on success and
-1 or NULL on failure.
#endif
typedef int key_t;
typedef enum guitar_e
{
S = ‘S’ /* solid body */,
H = ‘H’ /* hollow body */,
T = ‘T’ /* semi-hollow (thinline) */
} guitar_t
typedef enum pickup_e
{
H = ‘H’ /* humbucker */,
C = ‘C’ /* single coil */,
P = ‘P’ /* P90 */,
F = ‘F’ /* Filtertron */,
N = ‘N’ /* none */
} pickup_t;
typedef struct guitar_s {
key_t id_number;
char make[20];
char model [20];
char submodel[15];
guitar_t gtype;
int year; /* year of manufacture */
char finsh[25]; /* description of finish incuding color,
binding, etc. */
int strings; /* number of strings – usually 6 or 7 */
int pickups; /* number of pickups */
pickup_t neck; /* pickup type */
pickup_t middle; /* pickup type */
pickup_t bridge; /* pickup type */
} *guitar_t;
/* allocate a new struct guitar_s and return a pointer to it */
guitar_t guitar_init(void);
/* read from user all fields for a guitardb_guitar */
int guitardb_guitar_fill(guitardb_guitar_t);
/* set the id of a guitardb_guitar */
int guitardb_guitar_setid(guitardb_guitar_t, key_t);
/* get the id of a guitardb_guitar */
key_t guitardb_guitar_getid(guitar_t);
/* prints a guitardb_guitar */
int guitardb_guitar_print(guitar_t);
/* returns 0 if equal, <0 if less than, >0 if greater than */
int guitardb_guitar_compare(guitar_t, guitar_t);
void guitardb_guitar_free(guitar_t);
/*————————-*/
/* guitardb.h */
#if 0
This is the guitar database – it may call functions from the guitar
module or from the linked list module. To add a guitar, first call
guitar_init to get a new record, fill it in with guitar_fill, then call
guitardb_add to insert it into the database – which uses the linked
list rougtines to store it.
#endif
#include “guitar.h”
typedef struct guitardb_s
{
/* fill this in as needed */
} *guitardb_t;
/* initialize a new guitar database */
guitardb_t guitardb_init(void);
/* add a guitar to the database */
key_t guitardb_add(guitardb_t, guitar_t);
/* lookup a guitar by id return a pointer to it */
guitar_t guitardb_lookup(guitardb_t, key_t);
/* delete guitar from database, return pointer to it, do not free */
guitar_t guitardb_delete(guitardb_t, key_t);
.* reports all of the guitars in the database with it’s key, make,
model, and year, etc. *;
void guitardb_report(guitardb_t);
/* free all resources used by the guitar database */
void guitardb_finalize(guitardb_t);
/*————————-*/
/* list.h */
#if 0
Here is the header for the list ADT. Note all functions are in terms to data_t. This
must use a double-linked list. You code must accept as many entries as possible
until memory is exhausted. Your program must not have a memory leak – meaning
that at no time may data you have allocated be inaccessible or put another way, you
must always call free() on any memory your program will no longer keep up with.
Find, first, next, prev, and last return NULL if the requested item doesn’t exist.
#endif
typedef struct list *list_t;
typedef void *data_t;
typedef int (*cmpfunc)(data_t, data_t);
/* create a new empty list */
list_t list_init();
/* insert at head of list */
int list_insert(list_t, data_t);
/* append to tail of list */
int list_append(list_t, data_t);
/* find and sets current item using callback compare function */
data_t list_find(list_t, data_t, cmpfunc cmp);
/* return item at head of list, set current item */
data_t list_first(list_t);
/* return next item after current item */
data_t list_next(list_t);
/* return prev item before current item */
data_t list_prev(list_t);
/* return item at tail of list, set current item */
data_t list_last(list_t);
/* before current item */
int list_insert_before(list_t, data_t);
/* after current item */
int list_insert_after(list_t, data_t);
/* remove current item */
int list_remove(list_t);
/* free all resources allocated by the list */
int list_free(list_t);
/*————————-*/
ECE 223
