memopad_record.c

uclinux 下的一个记事本程序,可以供大家参考

#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#include "glib.h"
#include "zlib.h"

#include "memopad.h"
#include "memopad_record.h"
#include "glib.h"

#ifndef NOGDBM
#include "db.h"
#endif

#define NUM_OF_FIELDS 5
#define MEMOPAD_DATABASE "memopad.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)

static int memopad_record_size(Memo *memo, int *fieldSizes) {

    int sum = 0;
    
    setLength(sum, fieldSizes[0], sizeof(int)); /* memo->memo_id */
    setLength(sum, fieldSizes[1], strlen(memo->content) + 1);
    setLength(sum, fieldSizes[2], strlen(memo->encoding) + 1);
    setLength(sum, fieldSizes[3], sizeof(GDate));
    setLength(sum, fieldSizes[4], TITLE_LENGTH);
    return sum + sizeof(int) * NUM_OF_FIELDS + 1;
}

static int serialize(Memo *memo, char **raw_data) {

    int length;
    int sizes[NUM_OF_FIELDS];
    char *ptr;
    
    length = memopad_record_size(memo, sizes);
    
    *raw_data = g_new0(char, length);
    
    ptr = *raw_data;
    
    memcpy_offset_desc(ptr, sizes,            sizeof(int) * NUM_OF_FIELDS);
    memcpy_offset_desc(ptr, &(memo->memo_id), sizes[0]);
    memcpy_offset_desc(ptr, memo->content,    sizes[1]);
    memcpy_offset_desc(ptr, memo->encoding,   sizes[2]);
    memcpy_offset_desc(ptr, &(memo->date),    sizes[3]);
    memcpy_offset_desc(ptr, memo->title,      sizes[4]);
    return length;
}

void deserialize(Memo **memo, char *raw_data) {

    int sizes[NUM_OF_FIELDS];
    char *ptr;
    
    ptr = raw_data;
    *memo = g_new0(Memo, 1);
    
    memcpy_offset_src(sizes, ptr, sizeof(int) * NUM_OF_FIELDS);
    (*memo)->content = g_new0(char, sizes[1]);
    (*memo)->encoding = g_new0(char, sizes[2]);
    memcpy_offset_src(&((*memo)->memo_id), ptr, sizes[0]);
    memcpy_offset_src((*memo)->content,    ptr, sizes[1]);
    memcpy_offset_src((*memo)->encoding,   ptr, sizes[2]);
    memcpy_offset_src(&((*memo)->date),    ptr, sizes[3]);
    memcpy_offset_src((*memo)->title,      ptr, sizes[4]);
}

void memopad_record_destroy(Memo *memo) {
    g_return_if_fail(memo != NULL);
    
    if (memo->content)  g_free(memo->content);
    if (memo->encoding) g_free(memo->encoding);
    g_free(memo);
    
    memo = NULL;

}


int memopad_record_db_open() {
#ifndef NOGDBM
    int context;
    char *filename;
    char *path;
    
    //printf("%s: database file = %s\n", __FUNCTION__, filename);
    context = db_open(MEMOPAD_DATABASE, DB_WRITER | DB_CREATE_IF_NOT_EXIST);
    
    //g_free(filename);
    return context;
#else
    return 1;
#endif
}

void memopad_record_db_close(int context) {
#ifndef NOGDBM
    db_close(context);
#endif
}

void memopad_record_close(int context, Memo *memo) {

    if (memo->dirty)
        memopad_record_save(context, memo);
    
    g_free(memo);
}

Memo *memopad_record_new() {
    struct tm tm_now;
    time_t now;
    Memo *memo;
    
    now = time(NULL);
    localtime_r(&now, &tm_now);
    
    
    memo = g_new0(Memo, 1);
    memo->new = TRUE;
    g_date_clear(&(memo->date), 1);
    g_date_set_dmy(&(memo->date), tm_now.tm_mday, tm_now.tm_mon + 1,
        tm_now.tm_year + 1900);
    return memo;
}

Memo *memopad_record_load(int context, int key) {
#ifndef NOGDBM
    Memo *memo;
    char *raw_data;
    
    raw_data = db_fetch(context, key);
    
    g_return_val_if_fail(raw_data != NULL, NULL);
    
    deserialize(&memo, raw_data);
    memo->content_len = (memo->content != NULL)?  strlen (memo->content) : 0;
    
    memo->new     = FALSE;
    memo->dirty   = FALSE;
    
    g_free(raw_data);
    
    return memo;
#else
    return NULL;
#endif
}

int memopad_record_save(int context, Memo *memo) {
#ifndef NOGDBM
    char *raw_data;
    int record_length = 0, result;
    
    if (memo->new)
        memo->memo_id = db_getNextKey(context);
    
    record_length = serialize(memo, &raw_data);
    
    result = db_store(context, raw_data, record_length, !(memo->new), &(memo->memo_id));
    
    if (result == 0) {
        memo->dirty = FALSE;
        memo->new = FALSE;
    }
    
    free(raw_data);
    
    return result;
#else
    return 0;
#endif
}

int memopad_record_delete(int context, Memo *memo) {
#ifndef NOGDBM
    int result;
    
    g_return_val_if_fail(memo != NULL, -1);
    
    result = db_delete(context, memo->memo_id);
    
    return result;
#else
    return 0;
#endif
}