C - Serialisierungstechniken

Für jede Daten-Struktur, eine serialize_X Funktion (wobei X für die struct-name), die einen Zeiger auf ein X und ein Zeiger auf eine undurchsichtige Puffer-Struktur und ruft die entsprechende Serialisierung von Funktionen. Sie liefern sollte, einige primitive wie serialize_int die schreiben in den Puffer und aktualisieren der output-index.
Der primitive wird noch zu nennen so etwas wie reserve_space(N), wobei N die Anzahl von bytes, die erforderlich sind, bevor das schreiben von Daten. reserve_space() realloc void* Puffer, damit es wenigstens so groß, wie es die aktuelle Größe plus N bytes.
Um dies möglich zu machen, die Puffer-Struktur werden müssen, enthalten einen Zeiger auf die tatsächlichen Daten, die index zu schreiben, das nächste byte (output-index) und die Größe, die für Daten reserviert.
Mit diesem system werden alle Ihre serialize_X Funktionen sollte ziemlich einfach sein, zum Beispiel:

struct X {
    int n, m;
    char *string;
}

void serialize_X(struct X *x, struct Buffer *output) {
    serialize_int(x->n, output);
    serialize_int(x->m, output);
    serialize_string(x->string, output);
}

Und die framework-code wird so etwas wie:

#define INITIAL_SIZE 32

struct Buffer {
    void *data;
    int next;
    size_t size;
}

struct Buffer *new_buffer() {
    struct Buffer *b = malloc(sizeof(Buffer));

    b->data = malloc(INITIAL_SIZE);
    b->size = INITIAL_SIZE;
    b->next = 0;

    return b;
}

void reserve_space(Buffer *b, size_t bytes) {
    if((b->next + bytes) > b->size) {
        /* double size to enforce O(lg N) reallocs */
        b->data = realloc(b->data, b->size * 2);
        b->size *= 2;
    }
}

Aus dieser, es sollte Recht einfach zu implementieren alle serialize_ () - Funktionen, die Sie benötigen.

BEARBEITEN:
Zum Beispiel:

void serialize_int(int x, Buffer *b) {
    /* assume int == long; how can this be done better? */
    x = htonl(x);

    reserve_space(b, sizeof(int));

    memcpy(((char *)b->data) + b->next, &x, sizeof(int));
    b->next += sizeof(int);
}

BEARBEITEN:
Beachten Sie auch, dass mein code hat einige potenzielle bugs. Die Größe des Puffer-array gespeichert ist, in ein size_t aber der index ein int ist (ich bin mir nicht sicher, ob size_t ist als einer vernünftigen Typ für index). Auch gibt es keine Bestimmung für den Umgang mit Fehlern und keine Funktion, um freie Puffer, nachdem Sie fertig sind, so müssen Sie dies selbst tun. Ich war damit nur eine demonstration der grundlegenden Architektur, die ich benutzen würde.

InformationsquelleAutor der Antwort jstanley

Würde es helfen, wenn wir wüssten, was das Protokoll Einschränkungen, aber im Allgemeinen Ihre Möglichkeiten sind wirklich sehr begrenzt. Wenn die Daten so sind, dass Sie eine union von einem byte-array, sizeof(struct) für jede Struktur, die es vielleicht vereinfachen, aber aus Ihrer Beschreibung, es klingt wie Sie haben eine weitere wesentliche problem: wenn Sie bei der übertragung von Zeigern (die Sie erwähnen, void * data) dann werden diese Punkte sehr unwahrscheinlich gültig zu sein, auf der empfangenden Maschine. Warum würden die Daten vorkommt, ist an der gleichen Stelle im Speicher?

InformationsquelleAutor der Antwort Charlie Martin