Add subject to key/value chunks in RDFF (i.e. store triples).

git-svn-id: svn://localhost/ardour2/branches/3.0@9224 d708f5d6-7413-0410-9779-e7cbd77b26cf

diff --git a/libs/ardour/lv2_plugin.cc b/libs/ardour/lv2_plugin.cc
index 3832a899e7a8280db40cb22462935f2829e242b2..992a909b995edad02341eeae7a1befa4cab75783 100644 (file)
--- a/libs/ardour/lv2_plugin.cc
+++ b/libs/ardour/lv2_plugin.cc
@@ -367,10 +367,8 @@ LV2Plugin::lv2_persist_store_callback(void*       callback_data,
                                       uint32_t    type,
                                       bool        pod)
 {
-       cout << "LV2 PERSIST STORE " << key
-            << " = " << value
-            << " :: " << type
-            << " POD: " << pod << endl;
+       DEBUG_TRACE(DEBUG::LV2, string_compose("persist store %1\n",
+                                              _uri_map.id_to_uri(NULL, key)));
 
        PersistState* state = (PersistState*)callback_data;
        state->add_uri(key,  _uri_map.id_to_uri(NULL, key)); 
@@ -385,7 +383,8 @@ LV2Plugin::lv2_persist_retrieve_callback(void*     callback_data,
                                          uint32_t* type,
                                          bool*     pod)
 {
-       cout << "LV2 PERSIST RETRIEVE " << _uri_map.id_to_uri(NULL, key) << endl;
+       DEBUG_TRACE(DEBUG::LV2, string_compose("persist retrieve %1\n",
+                                              _uri_map.id_to_uri(NULL, key)));
 
        PersistState* state = (PersistState*)callback_data;
        PersistState::Values::const_iterator i = state->values.find(key);
@@ -447,8 +446,10 @@ LV2Plugin::add_state(XMLNode* root) const
                // Write all referenced URIs to state file
                for (PersistState::URIs::const_iterator i = state.uris.begin();
                     i != state.uris.end(); ++i) {
-                       rdff_write_uri(file, i->first,
-                                           i->second.c_str(), i->second.length() + 1);
+                       rdff_write_uri(file,
+                                      i->first,
+                                      i->second.length(),
+                                      i->second.c_str());
                }
 
                // Write all values to state file
@@ -456,11 +457,12 @@ LV2Plugin::add_state(XMLNode* root) const
                     i != state.values.end(); ++i) {
                        const uint32_t      key = i->first;
                        const PersistValue& val = i->second;
-                       rdff_write_value(file,
-                                             key,
-                                             val.value,
-                                             val.size,
-                                             val.type);
+                       rdff_write_triple(file,
+                                         0,
+                                         key,
+                                         val.type,
+                                         val.size,
+                                         val.value);
                }
 
                // Close state file
@@ -644,13 +646,14 @@ LV2Plugin::set_state(const XMLNode& node, int version)
                                        printf("READ URI %u: %s\n", body->id, body->uri);
                                        state.add_uri(body->id, body->uri);
                                } else if (!strncmp(chunk->type, "KVAL", 4)) {
-                                       RDFFValueChunk* body = (RDFFValueChunk*)chunk->data;
+                                       RDFFTripleChunk* body = (RDFFTripleChunk*)chunk->data;
                                        printf("READ VAL %u = %s (size: %u type: %u)\n",
-                                              body->key, body->value, body->size, body->type);
-                                       state.add_value(body->key,
-                                                       body->value,
-                                                       body->size,
-                                                       body->type,
+                                              body->predicate, body->object,
+                                              body->object_size, body->object_type);
+                                       state.add_value(body->predicate,
+                                                       body->object,
+                                                       body->object_size,
+                                                       body->object_type,
                                                        true);
                                }
                        }

diff --git a/libs/ardour/rdff.c b/libs/ardour/rdff.c
index 65ba893713ae7fe48addc6a63eae2ab350d89591..eacdc0b0af87b78a2e2e2f94a948ed00703b0829 100644 (file)
--- a/libs/ardour/rdff.c
+++ b/libs/ardour/rdff.c
@@ -35,8 +35,8 @@
 #define CHUNK_ID_LEN 4
 
 static const char FILE_TYPE[CHUNK_ID_LEN]  = "RDFF";  /* RDFF File ID */
-static const char CHUNK_KVAL[CHUNK_ID_LEN] = "KVAL";  /* Key/Value Chunk ID */
-static const char CHUNK_URID[CHUNK_ID_LEN] = "URID";  /* URI-ID Chunk ID*/
+static const char CHUNK_TRIP[CHUNK_ID_LEN] = "trip";  /* Triple Chunk ID */
+static const char CHUNK_URID[CHUNK_ID_LEN] = "urid";  /* URI-ID Chunk ID*/
 
 struct _RDFF {
        FILE*    fd;
@@ -98,8 +98,8 @@ rdff_open(const char* path, bool write)
 RDFFStatus
 rdff_write_uri(RDFF        file,
                uint32_t    id,
-               const char* uri,
-               uint32_t    len)
+               uint32_t    len,
+               const char* uri)
 {
        const uint32_t chunk_size = sizeof(id) + len + 1;
        WRITE(CHUNK_URID,  CHUNK_ID_LEN,       1, file->fd);
@@ -114,20 +114,22 @@ rdff_write_uri(RDFF        file,
 }
 
 RDFFStatus
-rdff_write_value(RDFF        file,
-                 uint32_t    key,
-                 const void* value,
-                 uint32_t    size,
-                 uint32_t    type)
+rdff_write_triple(RDFF        file,
+                  uint32_t    subject,
+                  uint32_t    predicate,
+                  uint32_t    object_type,
+                  uint32_t    object_size,
+                  const void* object)
 {
-       const uint32_t chunk_size = sizeof(key) + sizeof(type) + sizeof(size) + size;
-       WRITE(CHUNK_KVAL,  CHUNK_ID_LEN,       1, file->fd);
-       WRITE(&chunk_size, sizeof(chunk_size), 1, file->fd);
-       WRITE(&key,        sizeof(key),        1, file->fd);
-       WRITE(&type,       sizeof(type),       1, file->fd);
-       WRITE(&size,       sizeof(size),       1, file->fd);
-       WRITE(value,       size,               1, file->fd);
-       if ((size % 2)) {
+       const uint32_t chunk_size = sizeof(RDFFTripleChunk) + object_size;
+       WRITE(CHUNK_TRIP,   CHUNK_ID_LEN,        1, file->fd);
+       WRITE(&chunk_size,  sizeof(chunk_size),  1, file->fd);
+       WRITE(&subject,     sizeof(subject),     1, file->fd);
+       WRITE(&predicate,   sizeof(predicate),   1, file->fd);
+       WRITE(&object_type, sizeof(object_type), 1, file->fd);
+       WRITE(&object_size, sizeof(object_size), 1, file->fd);
+       WRITE(object,       object_size,         1, file->fd);
+       if ((object_size % 2)) {
                WRITE("", 1, 1, file->fd);  /* write pad */
        }
        file->size += 8 + chunk_size;
@@ -199,17 +201,18 @@ main(int argc, char** argv)
        char uri[64];
        for (int i = 0; i < N_URIS; ++i) {
                snprintf(uri, sizeof(uri), "http://example.org/uri%02d", i + 1);
-               rdff_write_uri(file, i + 1, uri, strlen(uri) + 1);
+               rdff_write_uri(file, i + 1, strlen(uri), uri);
        }
 
        char val[6];
        for (int i = 0; i < N_RECORDS; ++i) {
                snprintf(val, sizeof(val), "VAL%02d", i);
-               rdff_write_value(file,
-                                     rand() % N_URIS,
-                                     val,
-                                     sizeof(val),
-                                     0);
+               rdff_write_triple(file,
+                                 0,
+                                 rand() % N_URIS,
+                                 0,
+                                 sizeof(val),
+                                 val);
        }
 
        rdff_close(file);
@@ -222,8 +225,8 @@ main(int argc, char** argv)
        chunk->size = 0;
        for (int i = 0; i < N_URIS; ++i) {
                if (rdff_read_chunk(file, &chunk)
-                   || strncmp(chunk->type, "URID", 4)) {
-                       fprintf(stderr, "error: expected URID chunk\n");
+                   || strncmp(chunk->type, CHUNK_URID, 4)) {
+                       fprintf(stderr, "error: expected %s chunk\n", CHUNK_URID);
                        goto fail;
                }
                RDFFURIChunk* body = (RDFFURIChunk*)chunk->data;
@@ -232,12 +235,12 @@ main(int argc, char** argv)
 
        for (int i = 0; i < N_RECORDS; ++i) {
                if (rdff_read_chunk(file, &chunk)
-                   || strncmp(chunk->type, "KVAL", 4)) {
-                       fprintf(stderr, "error: expected KVAL chunk\n");
+                   || strncmp(chunk->type, CHUNK_TRIP, 4)) {
+                       fprintf(stderr, "error: expected %s chunk\n", CHUNK_TRIP);
                        goto fail;
                }
-               RDFFValueChunk* body = (RDFFValueChunk*)chunk->data;
-               printf("KEY %d = %s\n", body->key, body->value);
+               RDFFTripleChunk* body = (RDFFTripleChunk*)chunk->data;
+               printf("KEY %d = %s\n", body->predicate, body->object);
        }
 
        free(chunk);

diff --git a/libs/ardour/rdff.h b/libs/ardour/rdff.h
index 960085db04498cc03ae3bba142584596d5d16b7b..3d52553a4bad434fb57e0d557d1a0637f7af0d15 100644 (file)
--- a/libs/ardour/rdff.h
+++ b/libs/ardour/rdff.h
@@ -65,7 +65,7 @@ typedef struct {
 } PACKED RDFFChunk;
 
 /**
-   Body of a URID chunk.
+   Body of a RDFF "urid" chunk.
 */
 typedef struct {
        uint32_t id;     /**< Numeric ID of URI in this RDFF. */
@@ -73,14 +73,15 @@ typedef struct {
 } PACKED RDFFURIChunk;
 
 /**
-   Body of a KVAL chunk.
+   Body of a RDFF "trip" chunk.
 */
 typedef struct {
-       uint32_t key;      /**< Predicate URI ID. */
-       uint32_t type;     /**< Type URI ID. */
-       uint32_t size;     /**< Size of object data. */
-       char     value[];  /**< Object data. */
-} PACKED RDFFValueChunk;
+       uint32_t subject;      /**< Subject URI ID. */
+       uint32_t predicate;    /**< Predicate URI ID. */
+       uint32_t object_type;  /**< Object type URI ID. */
+       uint32_t object_size;  /**< Size of object data. */
+       char     object[];     /**< Object data. */
+} PACKED RDFFTripleChunk;
 
 /**
    Open/Create a new RDFF file.
@@ -94,18 +95,19 @@ rdff_open(const char* path, bool write);
 RDFFStatus
 rdff_write_uri(RDFF        file,
                uint32_t    id,
-               const char* uri,
-               uint32_t    len);
+               uint32_t    len,
+               const char* uri);
 
 /**
    Write a key/value record to @a file.
 */
 RDFFStatus
-rdff_write_value(RDFF        file,
-                 uint32_t    key,
-                 const void* value,
-                 uint32_t    size,
-                 uint32_t    type);
+rdff_write_triple(RDFF        file,
+                  uint32_t    subject,
+                  uint32_t    predicate,
+                  uint32_t    object_type,
+                  uint32_t    object_size,
+                  const void* object);
 
 /**
    Read a chunk from @a file.