Initial commit.

Author: KevinMGranger

.gitignore

@@ -0,0 +1 @@
+/target/

Cargo.lock

@@ -0,0 +1,16 @@
+[package]
+name = "nine"
+version = "0.2.0"
+description = "The 9p protocol as a serde format and message types."
+authors = ["Kevin M Granger <[email protected]>"]
+license = "MPL-2.0"
+
+[badges.maintenance]
+status = "experimental"
+
+[dependencies]
+serde = "1.0"
+serde_derive = "1.0"
+byteorder = "1.1.0"
+bitflags = "1.0.3"
+failure = "0.1.2"

Cargo.toml

@@ -0,0 +1,58 @@
+# Future Ideas
+
+## Progressive Type Enhancement
+
+Server implementers may wish for their users to not have to deal with tags. After all, there's essentially only one correct thing to do, so why not have
+the server handle it? This means users would only have to return the main part
+of the response.
+
+```rust 
+mod core_types {
+    pub struct Tversion {
+        pub msize: u32,
+        pub version: String
+    }
+
+    pub struct Rversion {
+        pub msize: u32,
+        pub version: String
+    }
+}
+mod tagged_types {
+    pub struct Tversion {
+        pub tag: u32,
+        #[serde(flatten)]
+        pub version: super::core_types::Tversion,
+    }
+    pub struct Rversion {
+        pub tag: u32,
+        #[serde(flatten)]
+        pub version: super::core_types::Rversion,
+    }
+}
+
+// then a server could have
+
+pub mod prelude {
+    pub use super::tagged_types::{Tversion, Tother}; // etc
+    pub use super::core_types::{Rversion, Rother}; // etc
+}
+
+// then the method could be
+
+fn version(&mut self, msg: Tversion) -> Result<Rversion>;
+
+// and thus the user has the tag if they want it, but don't have to return it.
+```
+
+## Ahead of time lengths
+
+We have to do length computation at serialize time because we can't specialize for structs (unless we manually implemented Serialize, which would defeat half of the point of this library, and make the types strange for other formats to deal with). This would be easier with specialization.
+
+But in the end, what does this get us? The ability to serialize a message without using a buffer-- but wouldn't we always want to use a buffer anyway?
+
+## Protocol extension
+
+There's plenty of types that don't exist in 9p-- floats, bools, maps, etc. For existing versions of the protocol, we can just ignore that. But part of the purpose of this library is allowing experimentation.
+
+Maybe we can make a trait that requires you to expose what the regular (de)serializer needs, but allows you to implement the (de)serialize methods yourself.