merge workspace and main crate

src/types.rs

@@ -0,0 +1,137 @@
+#[cfg(feature = "openapi")]
+use crate::OpenapiType;
+
+use gotham::hyper::body::Bytes;
+use mime::{Mime, APPLICATION_JSON};
+use serde::{de::DeserializeOwned, Serialize};
+use std::{
+	error::Error,
+	panic::RefUnwindSafe
+};
+
+#[cfg(not(feature = "openapi"))]
+pub trait ResourceType
+{
+}
+
+#[cfg(not(feature = "openapi"))]
+impl<T> ResourceType for T
+{
+}
+
+#[cfg(feature = "openapi")]
+pub trait ResourceType : OpenapiType
+{
+}
+
+#[cfg(feature = "openapi")]
+impl<T : OpenapiType> ResourceType for T
+{
+}
+
+
+/// A type that can be used inside a response body. Implemented for every type that is
+/// serializable with serde. If the `openapi` feature is used, it must also be of type
+/// `OpenapiType`.
+pub trait ResponseBody : ResourceType + Serialize
+{
+}
+
+impl<T : ResourceType + Serialize> ResponseBody for T
+{
+}
+
+
+/**
+This trait should be implemented for every type that can be built from an HTTP request body
+plus its media type. For most use cases it is sufficient to derive this trait, you usually
+don't need to manually implement this. Therefore, make sure that the first variable of
+your struct can be built from [`Bytes`], and the second one can be build from [`Mime`].
+If you have any additional variables, they need to be `Default`. This is an example of
+such a struct:
+
+```rust
+# #[macro_use] extern crate gotham_restful;
+# use gotham_restful::*;
+#[derive(FromBody, RequestBody)]
+#[supported_types(mime::IMAGE_GIF, mime::IMAGE_JPEG, mime::IMAGE_PNG)]
+struct RawImage {
+	content: Vec<u8>,
+	content_type: Mime
+}
+```
+
+ [`Bytes`]: ../bytes/struct.Bytes.html
+ [`Mime`]: ../mime/struct.Mime.html
+*/
+pub trait FromBody : Sized
+{
+	/// The error type returned by the conversion if it was unsuccessfull. When using the derive
+	/// macro, there is no way to trigger an error, so `Infallible` is used here. However, this
+	/// might change in the future.
+	type Err : Error;
+	
+	/// Perform the conversion.
+	fn from_body(body : Bytes, content_type : Mime) -> Result<Self, Self::Err>;
+}
+
+impl<T : DeserializeOwned> FromBody for T
+{
+	type Err = serde_json::Error;
+	
+	fn from_body(body : Bytes, _content_type : Mime) -> Result<Self, Self::Err>
+	{
+		serde_json::from_slice(&body)
+	}
+}
+
+
+/**
+A type that can be used inside a request body. Implemented for every type that is deserializable
+with serde. If the `openapi` feature is used, it must also be of type [`OpenapiType`].
+
+If you want a non-deserializable type to be used as a request body, e.g. because you'd like to
+get the raw data, you can derive it for your own type. All you need is to have a type implementing
+[`FromBody`] and optionally a list of supported media types:
+
+```rust
+# #[macro_use] extern crate gotham_restful;
+# use gotham_restful::*;
+#[derive(FromBody, RequestBody)]
+#[supported_types(mime::IMAGE_GIF, mime::IMAGE_JPEG, mime::IMAGE_PNG)]
+struct RawImage {
+	content: Vec<u8>,
+	content_type: Mime
+}
+```
+
+ [`FromBody`]: trait.FromBody.html
+ [`OpenapiType`]: trait.OpenapiType.html
+*/
+pub trait RequestBody : ResourceType + FromBody
+{
+	/// Return all types that are supported as content types. Use `None` if all types are supported.
+	fn supported_types() -> Option<Vec<Mime>>
+	{
+		None
+	}
+}
+
+impl<T : ResourceType + DeserializeOwned> RequestBody for T
+{
+	fn supported_types() -> Option<Vec<Mime>>
+	{
+		Some(vec![APPLICATION_JSON])
+	}
+}
+
+/// A type than can be used as a parameter to a resource method. Implemented for every type
+/// that is deserialize and thread-safe. If the `openapi` feature is used, it must also be of
+/// type `OpenapiType`.
+pub trait ResourceID : ResourceType + DeserializeOwned + Clone + RefUnwindSafe + Send + Sync
+{
+}
+
+impl<T : ResourceType + DeserializeOwned + Clone + RefUnwindSafe + Send + Sync> ResourceID for T
+{
+}