conflict-set/ConflictSet.h

#pragma once

#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
    Commit,
    /// The result of a check which intersects a write at a version >
    /// readVersion
    Conflict,
    /// The result of a check with a readVersion older than the highest call to
    /// `setOldestVersion`
    TooOld
  };
  /// Bytes ordered lexicographically
  struct Key {
    const uint8_t *p;
    int len;
  };
  /// Denotes a set of keys to be checked for conflicts
  struct ReadRange {
    Key begin;
    /// `end` having length 0 denotes that this range is the single key {begin}.
    /// Otherwise this denotes the range [begin, end)
    Key end;
    int64_t readVersion;
  };
  /// Denotes a set of keys to be considered written at `writeVersion`
  struct WriteRange {
    Key begin;
    /// `end` having length 0 denotes that this range is the single key {begin}.
    /// Otherwise this denotes the range [begin, end)
    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 check(const ReadRange *reads, Result *results, int count) const;
  /// `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 addWrites(const WriteRange *writes, int count);
  /// Reads where readVersion < oldestVersion will result in `TooOld`. Must be
  /// greater than any previous oldestVersion.
  void setOldestVersion(int64_t oldestVersion);

  /// Reads where readVersion < oldestVersion will result in `TooOld`. There are
  /// no writes initially.
  explicit ConflictSet(int64_t oldestVersion, uint64_t seed);
  ~ConflictSet();

#if __cplusplus > 199711L
  ConflictSet(ConflictSet &&) noexcept;
  ConflictSet &operator=(ConflictSet &&) noexcept;
  ConflictSet(const ConflictSet &) = delete;
  ConflictSet &operator=(const ConflictSet &) = delete;
#endif

  /// @private
  struct Impl;

private:
  Impl *impl;
};

#else

// c api

typedef struct ConflictSet ConflictSet;

typedef enum {
  /// 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
} ConflictSet_Result;
/// Bytes ordered lexicographically
typedef struct {
  const uint8_t *p;
  int len;
} ConflictSet_Key;
/// Denotes a set of keys to be checked for conflicts
typedef struct {
  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;
} ConflictSet_ReadRange;
/// Denotes a set of keys to be considered written at `writeVersion`
typedef struct {
  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;
} ConflictSet_WriteRange;

/// `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, uint64_t seed);
void ConflictSet_destroy(ConflictSet *cs);

#endif