1 files changed, 112 insertions, 0 deletions
diff --git a/ark/include/world.h b/ark/include/world.h
new file mode 100644
index 0000000..307608e
--- /dev/null
+++ b/ark/include/world.h
@@ -0,0 +1,112 @@
+#ifndef _WORLD_H_
+#define _WORLD_H_
+
+#include <dlfcn.h>
+#include <linux/limits.h>
+#include <pthread.h>
+#include <stdint.h>
+#include <wlr/types/wlr_input_device.h>
+#include <wlr/types/wlr_keyboard.h>
+#include <wlr/types/wlr_pointer.h>
+
+#include "world_exports.h"
+#include "world_types.h"
+
+#define MAX_QUEUED_ACTIONS 8
+
+typedef void *dlhandle_t;
+
+/* Opaque state for a world. Not to be touched by the harness (not that it
+ * really can be.) */
+
+struct WORLD;
+/* This structure represents an action requested by the world for the harness.
+ */
+typedef struct {
+  int (*action)(struct WORLD *requester, void *arg);
+  void (*arg_dtor)(void *arg);
+  union {
+    void *ptr_arg;
+    int int_arg;
+    char *str_arg;
+  };
+} requested_action_t;
+
+/*
+ * Structure for the world.
+ */
+typedef struct WORLD {
+  /* The argc this world is loaded with. Typically the argc from main(). */
+  int argc;
+
+  /* The argv this world is loaded with. Typically the argv from main(). */
+  char **argv;
+
+  /* Filename the world is loaded from. */
+  char filename[PATH_MAX];
+
+  /* Opaque state of this world. The state is usually some kind of pointer to
+   * the world state, but all the harness knows is the opaque state is a
+   * pointer-sized piece of data.
+   *
+   * This opaque state is used in a linear pattern where the handlers take the
+   * opaque state, maybe operate on it, and return a new opaque state, which is
+   * then passed to the next handler, etc. It is on the world to properly
+   * manager the memory for this state and to destroy it upon teardown.
+   *
+   * It's guaranteed that this state is used linearly, meaning the harness gives
+   * up all ownership to it once passed into a handler. */
+  opqst_t state;
+
+  /* This world's lock. This avoids potential issues with multiple threads
+   * trying to change the opaque state at once which can lead to undesireable
+   * outcomes. */
+  pthread_mutex_t lock;
+
+  /** Set to not-zero if this world is initialized, otherwise set to zero. */
+  int initialized;
+
+  /* The handle to the shared library. */
+  dlhandle_t library_handle;
+
+  /* Pointer to the world name. This is in the shared library and a
+   * null-terminated string. If the library does not have a world name, this
+   * will be NULL. */
+  const char *world_name;
+
+  /* World function table populated by the runtime loader. */
+#define WORLD_FN_PTR(ret, name, args) ret(*name) args;
+  ARKWORLD_EXPORTS(WORLD_FN_PTR)
+#undef WORLD_FN_PTR
+
+  /* List of requested actions by the world. Right now there is a maximum of 8
+   * allowed at one time. That should be plenty. The actions should be flushed
+   * after each call to a handler anyway. */
+  size_t n_requested_actions;
+  requested_action_t requested_actions[MAX_QUEUED_ACTIONS];
+} world_t;
+
+/* Reloads the world. This tears down the existing world, marshals the state
+ * for it and reloads it.
+ *
+ * This function will call dlclose on the world's library handle.
+ */
+int world_hot_reload(int argc, char **argv, const char *filepath,
+                     world_t *world);
+
+/*
+ * Like hot-reload, but uses the same parameters the world was originally
+ * loaded with.
+ */
+int world_hot_reload_same_state(world_t *world);
+
+/* Starts a world in a cold state. Called after load_world_from_file. */
+void world_cold_start(world_t *world);
+
+/* Reads a world from a filename. */
+int load_world_from_file(int argc, char **argv, const char *filename,
+                         world_t *world);
+
+void world_run_requested_actions(world_t *world);
+
+#endif /* _WORLD_H_ */