Make lib work as a c or c++ library

ConflictSet.h

@@ -2,6 +2,10 @@
 
 #include <stdint.h>
 
+#ifdef __cplusplus
+
+// c++ api
+
 struct __attribute__((__visibility__("default"))) ConflictSet {
   enum Result {
     /// The result of a check which does not intersect any conflicting writes
@@ -63,4 +67,64 @@ struct __attribute__((__visibility__("default"))) ConflictSet {
 
 private:
   Impl *impl;
-};
+};
+
+#else
+
+// c api
+
+typedef struct ConflictSet ConflictSet;
+
+enum ConflictSet_Result {
+  /// The result of a check which does not intersect any conflicting writes
+  ConflictSet_Commit,
+  /// The result of a check which intersects a write at a version >
+  /// readVersion
+  ConflictSet_Conflict,
+  /// The result of a check with a readVersion older than the highest call to
+  /// `setOldestVersion`
+  ConflictSet_TooOld,
+};
+/// Bytes ordered lexicographically
+struct ConflictSet_Key {
+  const uint8_t *p;
+  int len;
+};
+/// Denotes a set of keys to be checked for conflicts
+struct ConflictSet_ReadRange {
+  ConflictSet_Key begin;
+  /// `end` having length 0 denotes that this range is the single key {begin}.
+  /// Otherwise this denotes the range [begin, end)
+  ConflictSet_Key end;
+  int64_t readVersion;
+};
+/// Denotes a set of keys to be considered written at `writeVersion`
+struct ConflictSet_WriteRange {
+  ConflictSet_Key begin;
+  /// `end` having length 0 denotes that this range is the single key {begin}.
+  /// Otherwise this denotes the range [begin, end)
+  ConflictSet_Key end;
+  /// Write version must be greater than all write versions in all previous
+  /// calls to `addWrites`
+  int64_t writeVersion;
+};
+
+/// `reads` must be sorted ascending, and must not have adjacent or
+/// overlapping ranges. The result of checking reads[i] is written in
+/// results[i].
+void ConflictSet_check(ConflictSet *cs, const ConflictSet_ReadRange *reads,
+                       ConflictSet_Result *results, int count);
+/// `writes` must be sorted ascending, and must not have adjacent or
+/// overlapping ranges. Reads intersecting writes where readVersion <
+/// writeVersion will result in `Conflict` (or `TooOld`, eventually)
+void ConflictSet_addWrites(ConflictSet *cs,
+                           const ConflictSet_WriteRange *writes, int count);
+/// Reads where readVersion < oldestVersion will result in `TooOld`. Must be
+/// greater than any previous oldestVersion.
+void ConflictSet_setOldestVersion(ConflictSet *cs, int64_t oldestVersion);
+/// Reads where readVersion < oldestVersion will result in `TooOld`. There are
+/// no writes initially.
+ConflictSet *ConflictSet_create(int64_t oldestVersion);
+void ConflictSet_destroy(ConflictSet *cs);
+
+#endif