addressbook_record.c

在uclinux下写的一个 address book 程序

#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include "db.h"
#include "glib.h"

#include "common_util.h"

#include "addressbook_record.h"

#define REC_FIELDS              (NUM_OF_FIELDS + PERSONAL_NUM_OF_FIELDS + BUSINESS_NUM_OF_FIELDS)

#define ADDRESSBOOK_DATABASE "addressbook.db"

#define setLength(sum, array, size) \
    array = size; \
    sum += array;

#define memcpy_with_offset(desc, src, size, ptr) \
    memcpy(desc, src, size); \
    ptr += size;

#define memcpy_offset_desc(desc, src, size) memcpy_with_offset(desc, src, size, desc)
#define memcpy_offset_src(desc, src, size) memcpy_with_offset(desc, src, size, src)
#define memcpy_offset_src_new(desc, type, src, size) \
    desc = g_new0(type, size); \
    memcpy_offset_src(desc, src, size);
    
static int addressbook_record_size(Address *address, int *fieldSizes) {
    int sum = 0;
    
    setLength(sum, fieldSizes[0],  sizeof(int));
    setLength(sum, fieldSizes[1],  strlen(address->personal->lastName) + 1);
    setLength(sum, fieldSizes[2],  strlen(address->personal->firstName) + 1);
    setLength(sum, fieldSizes[3],  strlen(address->personal->nickName) + 1);
    setLength(sum, fieldSizes[4],  strlen(address->personal->phone) + 1);
    setLength(sum, fieldSizes[5],  strlen(address->personal->mobile) + 1);
    setLength(sum, fieldSizes[6],  strlen(address->personal->fax) + 1);
    setLength(sum, fieldSizes[7],  strlen(address->personal->email1) + 1);
    setLength(sum, fieldSizes[8],  strlen(address->personal->email2) + 1);
    setLength(sum, fieldSizes[9],  strlen(address->personal->email3) + 1);
    setLength(sum, fieldSizes[10], strlen(address->personal->address) + 1);
    setLength(sum, fieldSizes[11], strlen(address->personal->city) + 1);
    
    setLength(sum, fieldSizes[12], strlen(address->business->company) + 1);
    setLength(sum, fieldSizes[13], strlen(address->business->jobTitle) + 1);
    setLength(sum, fieldSizes[14], strlen(address->business->address) + 1);
    setLength(sum, fieldSizes[15], strlen(address->business->city) + 1);
    setLength(sum, fieldSizes[16], strlen(address->business->country) + 1);
    setLength(sum, fieldSizes[17], strlen(address->business->phone) + 1);
    setLength(sum, fieldSizes[18], strlen(address->business->mobile) + 1);
    setLength(sum, fieldSizes[19], strlen(address->business->fax) + 1);
    setLength(sum, fieldSizes[20], strlen(address->business->email) + 1);
    setLength(sum, fieldSizes[21], strlen(address->business->assistantName) + 1);
    setLength(sum, fieldSizes[22], strlen(address->business->assistantPhone) + 1);
    
    return sum + sizeof(int) * (REC_FIELDS) + 1;
}

static int serialize(Address *address, char **raw_data) {
    
    PersonalAddress *personal;
    BusinessAddress *business;
    
    int length;
    int sizes[REC_FIELDS];
    
    char *ptr;
    
    personal = address->personal;
    business = address->business;
    
    length = addressbook_record_size(address, sizes);
    
    *raw_data = g_new(char, length);
    
    ptr = *raw_data;
    
    memcpy_offset_desc(ptr,     sizes,                      sizeof(int) * (REC_FIELDS));
    memcpy_offset_desc(ptr,     &(address->address_id),     sizes[0]);
    memcpy_offset_desc(ptr,     personal->lastName,         sizes[1]);
    memcpy_offset_desc(ptr,     personal->firstName,        sizes[2]);
    memcpy_offset_desc(ptr,     personal->nickName,         sizes[3]);
    memcpy_offset_desc(ptr,     personal->phone,            sizes[4]);
    memcpy_offset_desc(ptr,     personal->mobile,           sizes[5]);
    memcpy_offset_desc(ptr,     personal->fax,              sizes[6]);
    memcpy_offset_desc(ptr,     personal->email1,           sizes[7]);
    memcpy_offset_desc(ptr,     personal->email2,           sizes[8]);
    memcpy_offset_desc(ptr,     personal->email3,           sizes[9]);
    memcpy_offset_desc(ptr,     personal->address,          sizes[10]);
    memcpy_offset_desc(ptr,     personal->city,             sizes[11]);
    
    memcpy_offset_desc(ptr,     business->company,          sizes[12]);
    memcpy_offset_desc(ptr,     business->jobTitle,         sizes[13]);
    memcpy_offset_desc(ptr,     business->address,          sizes[14]);
    memcpy_offset_desc(ptr,     business->city,             sizes[15]);
    memcpy_offset_desc(ptr,     business->country,          sizes[16]);
    memcpy_offset_desc(ptr,     business->phone,            sizes[17]);
    memcpy_offset_desc(ptr,     business->mobile,           sizes[18]);
    memcpy_offset_desc(ptr,     business->fax,              sizes[19]);
    memcpy_offset_desc(ptr,     business->email,            sizes[20]);
    memcpy_offset_desc(ptr,     business->assistantName,    sizes[21]);
    memcpy_offset_desc(ptr,     business->assistantPhone,   sizes[22]);
    
    return length;
}

void deserialize(Address **address, char *raw_data) {
    
    int sizes[REC_FIELDS];
    char *ptr;
    Address *addr;
    
    ptr = raw_data;
    addr = g_new(Address, 1);
    addr->personal = g_new(PersonalAddress, 1);
    addr->business = g_new(BusinessAddress, 1);
    
    memcpy_offset_src    (sizes,                            ptr, sizeof(int) * (REC_FIELDS));
    
    memcpy_offset_src    (&(addr->address_id),              ptr, sizes[0]);
    
    memcpy_offset_src_new(addr->personal->lastName,         char, ptr, sizes[1]);
    memcpy_offset_src_new(addr->personal->firstName,        char, ptr, sizes[2]);
    memcpy_offset_src_new(addr->personal->nickName,         char, ptr, sizes[3]);
    memcpy_offset_src_new(addr->personal->phone,            char, ptr, sizes[4]);
    memcpy_offset_src_new(addr->personal->mobile,           char, ptr, sizes[5]);
    memcpy_offset_src_new(addr->personal->fax,              char, ptr, sizes[6]);
    memcpy_offset_src_new(addr->personal->email1,           char, ptr, sizes[7]);
    memcpy_offset_src_new(addr->personal->email2,           char, ptr, sizes[8]);
    memcpy_offset_src_new(addr->personal->email3,           char, ptr, sizes[9]);
    memcpy_offset_src_new(addr->personal->address,          char, ptr, sizes[10]);
    memcpy_offset_src_new(addr->personal->city,             char, ptr, sizes[11]);
    
    
    memcpy_offset_src_new(addr->business->company,          char, ptr, sizes[12]);
    memcpy_offset_src_new(addr->business->jobTitle,         char, ptr, sizes[13]);
    memcpy_offset_src_new(addr->business->address,          char, ptr, sizes[14]);
    memcpy_offset_src_new(addr->business->city,             char, ptr, sizes[15]);
    memcpy_offset_src_new(addr->business->country,          char, ptr, sizes[16]);
    memcpy_offset_src_new(addr->business->phone,            char, ptr, sizes[17]);
    memcpy_offset_src_new(addr->business->mobile,           char, ptr, sizes[18]);
    memcpy_offset_src_new(addr->business->fax,              char, ptr, sizes[19]);
    memcpy_offset_src_new(addr->business->email,            char, ptr, sizes[20]);
    memcpy_offset_src_new(addr->business->assistantName,    char, ptr, sizes[21]);
    memcpy_offset_src_new(addr->business->assistantPhone,   char, ptr, sizes[22]);
    
    *address = addr;
}

int addressbook_record_db_open() {
                   
    int context;
    //char *filename;
    //char *path;
    
    /*
    path = getenv("DATABASE_PATH");
    
    if (path != NULL) {
        filename = g_strconcat(path, "/", ADDRESSBOOK_DATABASE, NULL);
    } else {
        filename = g_strdup(ADDRESSBOOK_DATABASE);
    }
    */
    
    //printf("%s: database file = %s\n", __FUNCTION__, filename);
    context = db_open(ADDRESSBOOK_DATABASE, DB_WRITER | DB_CREATE_IF_NOT_EXIST);
    
    //g_free(filename);
    return context;
}

void addressbook_record_db_close(int context) {
    db_close(context);
}

void addressbook_record_close(int context, Address *address) {
    if (address->dirty)
        addressbook_record_save(context, address);
    
    g_free(address);
}

void addressbook_record_destroy(Address *addr) {
    
    g_free(addr->personal->lastName);
    g_free(addr->personal->firstName);
    g_free(addr->personal->nickName);
    g_free(addr->personal->phone);
    g_free(addr->personal->mobile);
    g_free(addr->personal->fax);
    g_free(addr->personal->email1);
    g_free(addr->personal->email2);
    g_free(addr->personal->email3);
    g_free(addr->personal->address);
    g_free(addr->personal->city);
    
    g_free(addr->personal);


    g_free(addr->business->company);
    g_free(addr->business->jobTitle);
    g_free(addr->business->address);
    g_free(addr->business->city);
    g_free(addr->business->country);
    g_free(addr->business->phone);
    g_free(addr->business->mobile);
    g_free(addr->business->fax);
    g_free(addr->business->email);
    g_free(addr->business->assistantName);
    g_free(addr->business->assistantPhone);
    
    g_free(addr->business);
    
    g_free(addr);
}

Address *addressbook_record_new() {
    
    Address *address;
    
    address = g_new0(Address, 1);
    address->personal = g_new0(PersonalAddress, 1);
    
    address->personal->lastName    = g_strdup("");
    address->personal->firstName   = g_strdup("");
    address->personal->nickName    = g_strdup("");
    address->personal->phone       = g_strdup("");
    address->personal->mobile      = g_strdup("");
    address->personal->fax         = g_strdup("");
    address->personal->email1      = g_strdup("");
    address->personal->email2      = g_strdup("");
    address->personal->email3      = g_strdup("");
    address->personal->address     = g_strdup("");
    address->personal->city        = g_strdup("");
    
    address->business = g_new0(BusinessAddress, 1);
    
    address->business->company     = g_strdup("");
    address->business->jobTitle    = g_strdup("");
    address->business->address     = g_strdup("");
    address->business->city        = g_strdup("");
    address->business->country     = g_strdup("");
    address->business->phone       = g_strdup("");
    address->business->mobile      = g_strdup("");
    address->business->fax         = g_strdup("");
    address->business->email       = g_strdup("");
    address->business->assistantName = g_strdup(""); 
    address->business->assistantPhone = g_strdup("");
    
    address->new = TRUE;
    
    return address;
}

Address *addressbook_record_load(int context, int key) {
    Address *address;
    
    char *raw_data;
    
    raw_data = db_fetch(context, key);
    
    g_return_val_if_fail(raw_data != NULL, NULL);
 
    deserialize(&address, raw_data);
    
    address->new    = FALSE;
    address->dirty  = FALSE;
    
    g_free(raw_data);
    
    return address;
}

int addressbook_record_save(int context, Address *address) {
    
    char *raw_data;
    
    int record_length = 0, result;
    
    if (address->new)
        address->address_id = db_getNextKey(context);
    
    record_length = serialize(address, &raw_data);
    
    result = db_store(context, raw_data, record_length, !(address->new),
        &(address->address_id));
        
    if (result == 0) {
        address->dirty = FALSE;
        address->new   = FALSE;
    }
    
    return result;
}

int addressbook_record_delete(int context, Address *address) {
    
    int result;
    
    g_return_val_if_fail(address != NULL, -1);
    
    result = db_delete(context, address->address_id);
    
    return result;
}

#if 0
Address *addressbook_record_duplicate(Address *addr) {
    
    Address *new;
    
    new = g_new0(Address, 1);
    
    new->personal = g_new0(PersonalAddress, 1);
    new->business = g_new0(BusinessAddress, 1);
    
    new->personal->lastName =   g_strdup(addr->personal->lastName);
    new->personal->firstName =  g_strconcat(addr->personal->firstName, " Copy", NULL);
    new->personal->nickName =   g_strdup(addr->personal->nickName);
    new->personal->phone =      g_strdup(addr->personal->phone);
    new->personal->mobile =     g_strdup(addr->personal->mobile);
    new->personal->fax =        g_strdup(addr->personal->fax);
    new->personal->email1 =     g_strdup(addr->personal->email1);
    new->personal->email2 =     g_strdup(addr->personal->email2);
    new->personal->email3 =     g_strdup(addr->personal->email3);
    new->personal->address =    g_strdup(addr->personal->address);
    new->personal->city =       g_strdup(addr->personal->city);
    
    new->business->company =    g_strdup(addr->business->company);
    new->business->jobTitle =   g_strdup(addr->business->jobTitle);
    new->business->address =    g_strdup(addr->business->address);
    new->business->city =       g_strdup(addr->business->city);
    new->business->country =    g_strdup(addr->business->country);
    new->business->phone =      g_strdup(addr->business->phone);
    new->business->mobile =     g_strdup(addr->business->mobile);
    new->business->fax =        g_strdup(addr->business->fax);
    new->business->email =      g_strdup(addr->business->email);
    new->business->assistantName = g_strdup(addr->business->assistantName);
    new->business->assistantPhone = g_strdup(addr->business->assistantPhone);
    
    new->new    = TRUE;
    new->dirty  = TRUE;
    //new->address_id = 0;
    
    return new;
}
#endif

int addressbook_record_empty(Address *addr) {
    g_return_val_if_fail(addr != NULL, TRUE);
    g_return_val_if_fail(addr->personal != NULL, -1);
    g_return_val_if_fail(addr->business != NULL, -1);
    
    if (!strEmpty(addr->personal->lastName))
        return FALSE;
    
    if (!strEmpty(addr->personal->firstName))
        return FALSE;
    
    if (!strEmpty(addr->personal->nickName))
        return FALSE;
    
    if (!strEmpty(addr->personal->phone))
        return FALSE;
    
    if (!strEmpty(addr->personal->mobile))
        return FALSE;
    
    if (!strEmpty(addr->personal->fax))
        return FALSE;
    
    if (!strEmpty(addr->personal->email1))
        return FALSE;
    
    if (!strEmpty(addr->personal->email2))
        return FALSE;
    
    if (!strEmpty(addr->personal->email3))
        return FALSE;
    
    if (!strEmpty(addr->personal->address))
        return FALSE;
    
    if (!strEmpty(addr->personal->city))
        return FALSE;
    
    if (!strEmpty(addr->business->company))
        return FALSE;
    
    if (!strEmpty(addr->business->jobTitle))
        return FALSE;
    
    if (!strEmpty(addr->business->address))
        return FALSE;
    
    if (!strEmpty(addr->business->city))
        return FALSE;
    
    if (!strEmpty(addr->business->country))
        return FALSE;
    
    if (!strEmpty(addr->business->phone))
        return FALSE;
    
    if (!strEmpty(addr->business->mobile))
        return FALSE;
    
    if (!strEmpty(addr->business->fax))
        return FALSE;
    
    if (!strEmpty(addr->business->email))
        return FALSE;
    
    if (!strEmpty(addr->business->assistantName))
        return FALSE;
    
    if (!strEmpty(addr->business->assistantPhone))
        return FALSE;
    
    return TRUE;
}