feather-rs · caelunshun · May 4, 2020 · Defman · May 7, 2020 · Defman
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -1,6 +1,9 @@
 [workspace]
 members = [
     "api",
+    "api/common",
+    "api/macros",
+    "api/test-plugins/hello-world",
 
     "core",
     "core/anvil",

diff --git a/api/Cargo.toml b/api/Cargo.toml
@@ -1,7 +1,13 @@
 [package]
-name = "feather_api"
+name = "fapi"
 version = "0.1.0"
 authors = ["caelunshun <caelum12321@gmail.com>"]
 edition = "2018"
 
 [dependencies]
+fapi-common = { path = "common" }
+fapi-macros = { path = "macros" }
+
+serde_json = "1.0"
+bstr = "0.2"
+log = "0.4"
diff --git a/api/README.md b/api/README.md
@@ -0,0 +1,15 @@
+`fapi`, the plugin API used for Feather plugins.
+
+# Terminology
+
+"Host" refers to the server executable itself, while "plugin" refers to the plugin dynamic library.
+
+# Contents
+
+`common`: types and functions shared between the host and plugin implementation
+
+`macros`: procedural macros exposed to plugins
+
+`.`: the high-level plugin API exposed to plugins themselves
+
+`test-plugins`: test plugin crates
diff --git a/api/common/Cargo.toml b/api/common/Cargo.toml
@@ -0,0 +1,12 @@
+[package]
+name = "fapi-common"
+version = "0.1.0"
+authors = ["caelunshun <caelunshun@gmail.com>"]
+edition = "2018"
+
+[dependencies]
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+semver = { version = "0.9", features = ["serde"] }
+bstr = "0.2"
+log = "0.4"
diff --git a/api/common/src/event.rs b/api/common/src/event.rs
@@ -0,0 +1,18 @@
+//! Types associated with events.
+
+/// Unique ID of an event type.
+/// These are allocated opaquely
+/// by the host. No guarantees are made.
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[repr(transparent)]
+pub struct EventId(pub u64);
+
+/// Opaque type representing some avoid.
+///
+/// Pointers to this type may be casted
+/// to a concrete type, given the user
+/// knows the actual type of the event.
+#[repr(C)]
+pub struct OpaqueEvent {
+    _private: [u8; 0],
+}
diff --git a/api/common/src/lib.rs b/api/common/src/lib.rs
@@ -0,0 +1,6 @@
+pub mod event;
+pub mod log;
+pub mod states;
+pub mod system;
+pub mod util;
+pub mod vtable;
diff --git a/api/common/src/log.rs b/api/common/src/log.rs
@@ -0,0 +1,36 @@
+use log::Level;
+
+/// Level of a log message to print.
+#[repr(C)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum LogLevel {
+    Error,
+    Warn,
+    Info,
+    Debug,
+    Trace,
+}
+
+impl From<log::Level> for LogLevel {
+    fn from(level: Level) -> Self {
+        match level {
+            Level::Debug => LogLevel::Debug,
+            Level::Error => LogLevel::Error,
+            Level::Info => LogLevel::Info,
+            Level::Trace => LogLevel::Trace,
+            Level::Warn => LogLevel::Warn,
+        }
+    }
+}
+
+impl From<LogLevel> for log::Level {
+    fn from(level: LogLevel) -> Self {
+        match level {
+            LogLevel::Error => Level::Error,
+            LogLevel::Warn => Level::Warn,
+            LogLevel::Info => Level::Info,
+            LogLevel::Debug => Level::Debug,
+            LogLevel::Trace => Level::Trace,
+        }
+    }
+}
diff --git a/api/common/src/states.rs b/api/common/src/states.rs
@@ -0,0 +1,32 @@
+//! To implement the API, the host needs
+//! to access its state in host calls.
+//! To do this, it passes pointers to opaque
+//! types which store some data it needs
+//! to execute API requests.
+//!
+//! There are multiple state types used
+//! at different times in a plugin's lifecycle.
+
+/// The server's state at startup, which the plugin
+/// can use for access to startup functionality such
+/// as the system registry.
+#[repr(C)]
+pub struct StartupState {
+    _private: [u8; 0],
+}
+
+/// The server's state during the execution of a synchronous
+/// task on some region.
+#[repr(C)]
+pub struct GameState {
+    _private: [u8; 0],
+}
+
+/// The server's state potentially outside of the context of a synchronous
+/// region-local task.
+///
+/// Note that an `AsyncState` can be obtained through a `GameState`.
+#[repr(C)]
+pub struct AsyncState {
+    _private: [u8; 0],
+}
diff --git a/api/common/src/system.rs b/api/common/src/system.rs
@@ -0,0 +1,23 @@
+//! Defines types for registering systems and event handlers.
+
+use crate::event::{EventId, OpaqueEvent};
+use crate::states::GameState;
+
+/// Specifies a description of a system.
+#[repr(C)]
+pub struct SystemSpec {
+    /// A pointer to the function to run when the system is invoked.
+    pub f: fn(*mut GameState),
+}
+
+/// Specifies a description of an event handler.
+#[repr(C)]
+pub struct HandlerSpec {
+    /// The function to invoke when the handler runs.
+    ///
+    /// The function may assume the `OpaqueEvent` pointer
+    /// points to the event type associated with `event`.
+    pub f: fn(*mut GameState, *mut OpaqueEvent),
+    /// The ID of the event type which is to be handled by `f`.
+    pub event: EventId,
+}