Version 0.9

state_machine/kvstore.c

@@ -0,0 +1,118 @@
+#if defined(MAIN_SIMULATION) || defined(MAIN_TEST)
+#define QUAKEY_ENABLE_MOCKS
+#endif
+
+#include <quakey.h>
+#include <assert.h>
+#include <stdio.h>
+
+#include "kvstore.h"
+
+void kvstore_init(KVStore *kvs)
+{
+    memset(kvs, 0, sizeof(*kvs));
+}
+
+void kvstore_free(KVStore *kvs)
+{
+    (void) kvs;
+}
+
+static int find_entry(KVStore *kvs, char *key)
+{
+    for (int i = 0; i < kvs->count; i++)
+        if (!memcmp(kvs->entries[i].key, key, KVSTORE_KEY_SIZE))
+            return i;
+    return -1;
+}
+
+KVStoreResult kvstore_update(KVStore *kvs, KVStoreOper oper)
+{
+    KVStoreResult result;
+    switch (oper.type) {
+    case KVSTORE_OPER_NOOP:
+        result.type = KVSTORE_RESULT_OK;
+        result.val = 0;
+        break;
+    case KVSTORE_OPER_SET:
+        {
+            int i = find_entry(kvs, oper.key);
+            if (i < 0) {
+                if (kvs->count >= KVSTORE_ENTRY_LIMIT) {
+                    result.type = KVSTORE_RESULT_FULL;
+                    result.val = 0;
+                    break;
+                }
+                i = kvs->count++;
+                memcpy(kvs->entries[i].key, oper.key, KVSTORE_KEY_SIZE);
+            }
+            kvs->entries[i].val = oper.val;
+
+            result.type = KVSTORE_RESULT_OK;
+            result.val = 0;
+        }
+        break;
+    case KVSTORE_OPER_GET:
+        {
+            int i = find_entry(kvs, oper.key);
+            if (i < 0) {
+                result.type = KVSTORE_RESULT_MISSING;
+                result.val = 0;
+            } else {
+                result.type = KVSTORE_RESULT_OK;
+                result.val  = kvs->entries[i].val;
+            }
+        }
+        break;
+    case KVSTORE_OPER_DEL:
+        {
+            int i = find_entry(kvs, oper.key);
+            if (i < 0) {
+                result.type = KVSTORE_RESULT_MISSING;
+                result.val = 0;
+            } else {
+                result.type = KVSTORE_RESULT_OK;
+                result.val  = kvs->entries[i].val;
+                kvs->entries[i] = kvs->entries[--kvs->count];
+            }
+        }
+        break;
+    default:
+        assert(0);
+        break;
+    }
+
+    return result;
+}
+
+void kvstore_dump_oper(KVStoreOper oper)
+{
+    switch (oper.type) {
+        case KVSTORE_OPER_NOOP: printf("NOOP"); break;
+        case KVSTORE_OPER_SET: printf("SET(%.16s, %lu)", oper.key, oper.val); break;
+        case KVSTORE_OPER_GET: printf("GET(%.16s)", oper.key); break;
+        case KVSTORE_OPER_DEL: printf("DEL(%.16s)", oper.key); break;
+        default: printf("???\n");
+    }
+}
+
+int kvstore_snprint_oper(char *buf, int size, KVStoreOper oper)
+{
+    switch (oper.type) {
+    case KVSTORE_OPER_NOOP: return snprintf(buf, size, "NOOP");
+    case KVSTORE_OPER_SET:  return snprintf(buf, size, "SET(%.16s, %lu)", oper.key, oper.val);
+    case KVSTORE_OPER_GET:  return snprintf(buf, size, "GET(%.16s)", oper.key);
+    case KVSTORE_OPER_DEL:  return snprintf(buf, size, "DEL(%.16s)", oper.key);
+    default:                return snprintf(buf, size, "???");
+    }
+}
+
+int kvstore_snprint_result(char *buf, int size, KVStoreResult result)
+{
+    switch (result.type) {
+    case KVSTORE_RESULT_OK:      return snprintf(buf, size, "OK(%lu)", result.val);
+    case KVSTORE_RESULT_FULL:    return snprintf(buf, size, "FULL");
+    case KVSTORE_RESULT_MISSING: return snprintf(buf, size, "MISSING");
+    default:                     return snprintf(buf, size, "???");
+    }
+}

state_machine/kvstore.h

@@ -0,0 +1,51 @@
+#ifndef KVSTORE_INCLUDED
+#define KVSTORE_INCLUDED
+
+#include <stdint.h>
+
+#define KVSTORE_KEY_SIZE 16
+#define KVSTORE_ENTRY_LIMIT 64
+
+typedef enum {
+    KVSTORE_OPER_NOOP,
+    KVSTORE_OPER_SET,
+    KVSTORE_OPER_GET,
+    KVSTORE_OPER_DEL,
+} KVStoreOperType;
+
+typedef enum {
+    KVSTORE_RESULT_OK,
+    KVSTORE_RESULT_FULL,
+    KVSTORE_RESULT_MISSING,
+} KVStoreResultType;
+
+typedef struct {
+    KVStoreOperType type;
+    char key[KVSTORE_KEY_SIZE];
+    uint64_t val;
+} KVStoreOper;
+
+typedef struct {
+    KVStoreResultType type;
+    uint64_t val;
+} KVStoreResult;
+
+typedef struct {
+    char     key[KVSTORE_KEY_SIZE];
+    uint64_t val;
+} KVEntry;
+
+typedef struct {
+    int count;
+    KVEntry entries[KVSTORE_ENTRY_LIMIT];
+} KVStore;
+
+void          kvstore_init(KVStore *kvs);
+void          kvstore_free(KVStore *kvs);
+KVStoreResult kvstore_update(KVStore *kvs, KVStoreOper oper);
+
+void kvstore_dump_oper(KVStoreOper oper);
+int  kvstore_snprint_oper(char *buf, int size, KVStoreOper oper);
+int  kvstore_snprint_result(char *buf, int size, KVStoreResult result);
+
+#endif // KVSTORE_INCLUDED

state_machine/state_machine.c

@@ -1,25 +0,0 @@
-#if defined(MAIN_SIMULATION) || defined(MAIN_TEST)
-#define QUAKEY_ENABLE_MOCKS
-#endif
-
-#include <quakey.h>
-#include <assert.h>
-
-#include "state_machine.h"
-
-void state_machine_init(StateMachine *sm)
-{
-    (void)sm;
-}
-
-void state_machine_free(StateMachine *sm)
-{
-    (void)sm;
-}
-
-OperationResult state_machine_update(StateMachine *sm, Operation op)
-{
-    (void)sm;
-    (void)op;
-    return OPERATION_RESULT_X;
-}

state_machine/state_machine.h

@@ -1,26 +0,0 @@
-#ifndef STATE_MACHINE_INCLUDED
-#define STATE_MACHINE_INCLUDED
-
-typedef enum {
-    OPERATION_NOOP,
-    OPERATION_A,
-    OPERATION_B,
-    OPERATION_C,
-} Operation;
-
-typedef enum {
-    OPERATION_RESULT_X,
-    OPERATION_RESULT_Y,
-    OPERATION_RESULT_Z,
-} OperationResult;
-
-typedef struct {
-
-} StateMachine;
-
-void state_machine_init(StateMachine *sm);
-void state_machine_free(StateMachine *sm);
-
-OperationResult state_machine_update(StateMachine *sm, Operation op);
-
-#endif // STATE_MACHINE_INCLUDED