Replace multiple stream callbacks with SerdEvent

This makes plumbing easier since everything goes through the same "stream" and
only one callback is required to handling everything.  It's also more easily
extensible in case more event types need to be added in the future.

4 files changed, 49 insertions, 45 deletions

diff --git a/src/env.c b/src/env.c
index 526e72c5..c8ac437e 100644
--- a/src/env.c
+++ b/src/env.c
@@ -249,11 +249,9 @@ serd_env_expand_node(const SerdEnv* const env, const SerdNode* const node)
 }
 
 void
-serd_env_foreach(const SerdEnv* const env,
-                 const SerdPrefixFunc func,
-                 void* const          handle)
+serd_env_write_prefixes(const SerdEnv* const env, const SerdSink* const sink)
 {
   for (size_t i = 0; i < env->n_prefixes; ++i) {
-    func(handle, env->prefixes[i].name, env->prefixes[i].uri);
+    serd_sink_write_prefix(sink, env->prefixes[i].name, env->prefixes[i].uri);
   }
 }
diff --git a/src/sink.c b/src/sink.c
index f78a0f18..4b7c6646 100644
--- a/src/sink.c
+++ b/src/sink.c
@@ -24,11 +24,14 @@
 #include <stdlib.h>
 
 SerdSink*
-serd_sink_new(void* handle, SerdFreeFunc free_handle)
+serd_sink_new(void* const   handle,
+              SerdEventFunc event_func,
+              SerdFreeFunc  free_handle)
 {
   SerdSink* sink = (SerdSink*)calloc(1, sizeof(SerdSink));
 
   sink->handle      = handle;
+  sink->on_event    = event_func;
   sink->free_handle = free_handle;
 
   return sink;
@@ -47,37 +50,18 @@ serd_sink_free(SerdSink* sink)
 }
 
 SerdStatus
-serd_sink_set_base_func(SerdSink* sink, SerdBaseFunc base_func)
+serd_sink_write_event(const SerdSink* sink, const SerdEvent* event)
 {
-  sink->base = base_func;
-  return SERD_SUCCESS;
-}
-
-SerdStatus
-serd_sink_set_prefix_func(SerdSink* sink, SerdPrefixFunc prefix_func)
-{
-  sink->prefix = prefix_func;
-  return SERD_SUCCESS;
-}
-
-SerdStatus
-serd_sink_set_statement_func(SerdSink* sink, SerdStatementFunc statement_func)
-{
-  sink->statement = statement_func;
-  return SERD_SUCCESS;
-}
-
-SerdStatus
-serd_sink_set_end_func(SerdSink* sink, SerdEndFunc end_func)
-{
-  sink->end = end_func;
-  return SERD_SUCCESS;
+  return sink->on_event ? sink->on_event(sink->handle, event) : SERD_SUCCESS;
 }
 
 SerdStatus
 serd_sink_write_base(const SerdSink* sink, const SerdNode* uri)
 {
-  return sink->base ? sink->base(sink->handle, uri) : SERD_SUCCESS;
+  const SerdBaseEvent ev = {SERD_BASE, uri};
+
+  return sink->on_event ? sink->on_event(sink->handle, (const SerdEvent*)&ev)
+                        : SERD_SUCCESS;
 }
 
 SerdStatus
@@ -85,7 +69,10 @@ serd_sink_write_prefix(const SerdSink* sink,
                        const SerdNode* name,
                        const SerdNode* uri)
 {
-  return sink->prefix ? sink->prefix(sink->handle, name, uri) : SERD_SUCCESS;
+  const SerdPrefixEvent ev = {SERD_PREFIX, name, uri};
+
+  return sink->on_event ? sink->on_event(sink->handle, (const SerdEvent*)&ev)
+                        : SERD_SUCCESS;
 }
 
 SerdStatus
@@ -93,8 +80,11 @@ serd_sink_write_statement(const SerdSink*          sink,
                           const SerdStatementFlags flags,
                           const SerdStatement*     statement)
 {
-  return sink->statement ? sink->statement(sink->handle, flags, statement)
-                         : SERD_SUCCESS;
+  const SerdStatementEvent statement_ev = {SERD_STATEMENT, flags, statement};
+  SerdEvent                ev           = {SERD_STATEMENT};
+  ev.statement                          = statement_ev;
+
+  return sink->on_event ? sink->on_event(sink->handle, &ev) : SERD_SUCCESS;
 }
 
 SerdStatus
@@ -117,5 +107,8 @@ serd_sink_write(const SerdSink*          sink,
 SerdStatus
 serd_sink_write_end(const SerdSink* sink, const SerdNode* node)
 {
-  return sink->end ? sink->end(sink->handle, node) : SERD_SUCCESS;
+  const SerdEndEvent ev = {SERD_END, node};
+
+  return sink->on_event ? sink->on_event(sink->handle, (const SerdEvent*)&ev)
+                        : SERD_SUCCESS;
 }
diff --git a/src/sink.h b/src/sink.h
index e0f99a53..6e8dffe3 100644
--- a/src/sink.h
+++ b/src/sink.h
@@ -23,12 +23,9 @@
    An interface that receives a stream of RDF data.
 */
 struct SerdSinkImpl {
-  void*             handle;
-  SerdFreeFunc      free_handle;
-  SerdBaseFunc      base;
-  SerdPrefixFunc    prefix;
-  SerdStatementFunc statement;
-  SerdEndFunc       end;
+  void*         handle;
+  SerdFreeFunc  free_handle;
+  SerdEventFunc on_event;
 };
 
 #endif // SERD_SINK_H
diff --git a/src/writer.c b/src/writer.c
index 4e628cc2..66a53819 100644
--- a/src/writer.c
+++ b/src/writer.c
@@ -915,6 +915,25 @@ serd_writer_end_anon(SerdWriter* writer, const SerdNode* node)
   return SERD_SUCCESS;
 }
 
+static SerdStatus
+serd_writer_on_event(SerdWriter* writer, const SerdEvent* event)
+{
+  switch (event->type) {
+  case SERD_BASE:
+    return serd_writer_set_base_uri(writer, event->base.uri);
+  case SERD_PREFIX:
+    return serd_writer_set_prefix(
+      writer, event->prefix.name, event->prefix.uri);
+  case SERD_STATEMENT:
+    return serd_writer_write_statement(
+      writer, event->statement.flags, event->statement.statement);
+  case SERD_END:
+    return serd_writer_end_anon(writer, event->end.node);
+  }
+
+  return SERD_ERR_BAD_ARG;
+}
+
 SerdStatus
 serd_writer_finish(SerdWriter* writer)
 {
@@ -955,11 +974,8 @@ serd_writer_new(SerdWorld*      world,
   writer->byte_sink  = serd_byte_sink_new(
     ssink, stream, (flags & SERD_WRITE_BULK) ? SERD_PAGE_SIZE : 1);
 
-  writer->iface.handle    = writer;
-  writer->iface.base      = (SerdBaseFunc)serd_writer_set_base_uri;
-  writer->iface.prefix    = (SerdPrefixFunc)serd_writer_set_prefix;
-  writer->iface.statement = (SerdStatementFunc)serd_writer_write_statement;
-  writer->iface.end       = (SerdEndFunc)serd_writer_end_anon;
+  writer->iface.handle   = writer;
+  writer->iface.on_event = (SerdEventFunc)serd_writer_on_event;
 
   return writer;
 }