Add model and serd-sort utility

With all the new functionality, the complexity of the serd-pipe command-line
interface is starting to push the limits of available flags. So, instead of
grafting on further options to control a model, this commit adds a new tool,
serd-sort, which acts somewhat like a stripped-down serd-pipe that stores
statements in a model in memory.

This keeps the complexity (including the user-facing complexity) of any one
tool down, since other more focused tools can be used for streaming tasks in a
pipeline.

In other words, abandon Swissarmyknifeism, take a page from the Unix
philosophy, and try to expose the model functionality to the command-line in a
dedicated focused tool.  The model implementation is tested by using this tool
to run a subset of the usual test suites, and a special suite to test statement
sorting.

1 files changed, 147 insertions, 0 deletions

diff --git a/src/compare.c b/src/compare.c
new file mode 100644
index 00000000..2ce49cc2
--- /dev/null
+++ b/src/compare.c
@@ -0,0 +1,147 @@
+// Copyright 2011-2021 David Robillard <d@drobilla.net>
+// SPDX-License-Identifier: ISC
+
+#include "compare.h"
+
+#include "statement.h" // IWYU pragma: keep
+
+#include "serd/node.h"
+#include "serd/statement.h"
+#include "zix/attributes.h"
+
+#include <assert.h>
+
+/// Compare a mandatory node with a node pattern
+ZIX_PURE_FUNC static inline int
+serd_node_wildcard_compare(const SerdNode* ZIX_NONNULL  a,
+                           const SerdNode* ZIX_NULLABLE b)
+{
+  assert(a);
+  return b ? serd_node_compare(a, b) : 0;
+}
+
+/// Compare an optional graph node with a node pattern
+static inline int
+serd_node_graph_compare(const SerdNode* ZIX_NULLABLE a,
+                        const SerdNode* ZIX_NULLABLE b)
+{
+  if (a == b) {
+    return 0;
+  }
+
+  if (!a) {
+    return -1;
+  }
+
+  if (!b) {
+    return 1;
+  }
+
+  return serd_node_compare(a, b);
+}
+
+/// Compare statements lexicographically, ignoring graph
+int
+serd_triple_compare(const void* const x,
+                    const void* const y,
+                    const void* const user_data)
+{
+  const int* const           ordering = (const int*)user_data;
+  const SerdStatement* const s        = (const SerdStatement*)x;
+  const SerdStatement* const t        = (const SerdStatement*)y;
+
+  for (unsigned i = 0U; i < 3U; ++i) {
+    const int o = ordering[i];
+    assert(o < 3);
+
+    const int c = serd_node_compare(s->nodes[o], t->nodes[o]);
+    if (c) {
+      return c;
+    }
+  }
+
+  return 0;
+}
+
+/**
+   Compare statments with statement patterns lexicographically, ignoring graph.
+
+   Null nodes in the second argument are treated as wildcards, always less than
+   any node.
+*/
+int
+serd_triple_compare_pattern(const void* const x,
+                            const void* const y,
+                            const void* const user_data)
+{
+  const int* const           ordering = (const int*)user_data;
+  const SerdStatement* const s        = (const SerdStatement*)x;
+  const SerdStatement* const t        = (const SerdStatement*)y;
+
+  for (unsigned i = 0U; i < 3U; ++i) {
+    const int o = ordering[i];
+    assert(o < 3);
+
+    const int c = serd_node_wildcard_compare(s->nodes[o], t->nodes[o]);
+    if (c) {
+      return c;
+    }
+  }
+
+  return 0;
+}
+
+/// Compare statements lexicographically
+int
+serd_quad_compare(const void* const x,
+                  const void* const y,
+                  const void* const user_data)
+{
+  const int* const           ordering = (const int*)user_data;
+  const SerdStatement* const s        = (const SerdStatement*)x;
+  const SerdStatement* const t        = (const SerdStatement*)y;
+
+  for (unsigned i = 0U; i < 4U; ++i) {
+    const int o = ordering[i];
+    const int c =
+      (o == SERD_GRAPH)
+        ? serd_node_graph_compare(s->nodes[SERD_GRAPH], t->nodes[SERD_GRAPH])
+        : serd_node_compare(s->nodes[o], t->nodes[o]);
+
+    if (c) {
+      return c;
+    }
+  }
+
+  return 0;
+}
+
+/**
+   Compare statments with statement patterns lexicographically.
+
+   Null nodes in the second argument are treated as wildcards, always less than
+   any node.
+*/
+int
+serd_quad_compare_pattern(const void* const x,
+                          const void* const y,
+                          const void* const user_data)
+{
+  const int* const           ordering = (const int*)user_data;
+  const SerdStatement* const s        = (const SerdStatement*)x;
+  const SerdStatement* const t        = (const SerdStatement*)y;
+
+  for (unsigned i = 0U; i < 4U; ++i) {
+    const int o = ordering[i];
+    const int c =
+      (o == SERD_GRAPH)
+        ? serd_node_graph_compare(s->nodes[SERD_GRAPH], t->nodes[SERD_GRAPH])
+        : serd_node_wildcard_compare(s->nodes[o], t->nodes[o]);
+
+    if (c) {
+      return c;
+    }
+  }
+
+  return 0;
+}