RDFF - RDF in RIFF
Copyright 2011 David Robillard <http://drobilla.net>
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
- this list of conditions and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright
- notice, this list of conditions and the following disclaimer in the
- documentation and/or other materials provided with the distribution.
-
- THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
- INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
- AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
- AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
- OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
- THE POSSIBILITY OF SUCH DAMAGE.
+ Permission to use, copy, modify, and/or distribute this software for any
+ purpose with or without fee is hereby granted, provided that the above
+ copyright notice and this permission notice appear in all copies.
+
+ THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include <assert.h>
#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;
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);
}
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;
return RDFF_STATUS_OK;
}
+bool
+rdff_chunk_is_uri(RDFFChunk* chunk)
+
+{
+ return !strncmp(chunk->type, CHUNK_URID, CHUNK_ID_LEN);
+}
+
+bool
+rdff_chunk_is_triple(RDFFChunk* chunk)
+{
+ return !strncmp(chunk->type, CHUNK_TRIP, CHUNK_ID_LEN);
+}
+
void
rdff_close(RDFF file)
{
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);
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;
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);
projects / ardour.git / blobdiff