Added Value type.

Converted all json::Value to Value (mostly zero allocs).
Changed all imports to sorted imports (with some kind of order, at least)

Author: rakshith-ravi

src/connection/unix_socket_connection.rs

@@ -1,3 +1,8 @@
+use crate::{
+	connection::{BaseConnection, Buffer},
+	utils::Error,
+};
+
 use async_std::{io::BufReader, os::unix::net::UnixStream, prelude::*, task};
 use async_trait::async_trait;
 
@@ -10,11 +15,6 @@ use futures::{
 };
 use futures_util::SinkExt;
 
-use crate::{
-	connection::{BaseConnection, Buffer},
-	utils::Error,
-};
-
 pub struct UnixSocketConnection {
 	connection_setup: bool,
 	read_data_receiver: Option<UnboundedReceiver<Vec<u8>>>,

src/gotham_module.rs

@@ -1,9 +1,10 @@
 use crate::{
 	connection::{BaseConnection, Buffer, UnixSocketConnection},
-	models::BaseMessage,
+	models::{BaseMessage, Value},
 	protocol::BaseProtocol,
 	utils::{self, Error, Result},
 };
+use std::collections::HashMap;
 use async_std::{
 	prelude::*,
 	sync::{Arc, Mutex},
@@ -14,11 +15,9 @@ use futures::channel::{
 	oneshot::{channel, Sender},
 };
 use futures_util::sink::SinkExt;
-use serde_json::{Map, Value};
-use std::collections::HashMap;
 
 type ArcRequestList = Arc<Mutex<HashMap<String, Sender<Result<Value>>>>>;
-type ArcFunctionList = Arc<Mutex<HashMap<String, fn(Map<String, Value>) -> Value>>>;
+type ArcFunctionList = Arc<Mutex<HashMap<String, fn(HashMap<String, Value>) -> Value>>>;
 type ArcHookListenerList = Arc<Mutex<HashMap<String, Vec<fn(Value)>>>>;
 
 pub struct GothamModule {
@@ -74,7 +73,7 @@ impl GothamModule {
 	pub async fn declare_function(
 		&mut self,
 		fn_name: String,
-		function: fn(Map<String, Value>) -> Value,
+		function: fn(HashMap<String, Value>) -> Value,
 	) -> Result<()> {
 		self.functions
 			.lock()
@@ -89,7 +88,7 @@ impl GothamModule {
 	pub async fn call_function(
 		&mut self,
 		fn_name: String,
-		args: Map<String, Value>,
+		args: HashMap<String, Value>,
 	) -> Result<Value> {
 		self.ensure_registered()?;
 		let request = self.protocol.call_function(fn_name, args);
@@ -172,19 +171,18 @@ impl GothamModule {
 			}
 		}
 
-		let mut encoded = self.protocol.encode(&request);
-		if self.registered || request.get_type() == 1 {
+		let request_type = request.get_type();
+		let request_id = request.get_request_id().clone();
+		let mut encoded = self.protocol.encode(request);
+		if self.registered || request_type == 1 {
 			self.connection.send(encoded).await;
 		} else {
 			self.message_buffer.append(&mut encoded);
 		}
 
 		let (sender, receiver) = channel::<Result<Value>>();
 
-		self.requests
-			.lock()
-			.await
-			.insert(request.get_request_id().clone(), sender);
+		self.requests.lock().await.insert(request_id, sender);
 
 		match receiver.await {
 			Ok(value) => value,
@@ -213,11 +211,11 @@ async fn on_data_listener(
 			BaseMessage::FunctionCallRequest { .. } => {
 				let result = execute_function_call(message, &functions).await;
 				let write_buffer = match result {
-					Ok(value) => protocol.encode(&BaseMessage::FunctionCallResponse {
+					Ok(value) => protocol.encode(BaseMessage::FunctionCallResponse {
 						request_id: request_id.clone(),
 						data: value,
 					}),
-					Err(error) => protocol.encode(&BaseMessage::Error {
+					Err(error) => protocol.encode(BaseMessage::Error {
 						request_id: request_id.clone(),
 						error: match error {
 							Error::Internal(_) => 0,

src/models/json_value.rs

@@ -0,0 +1,74 @@
+use crate::models::{Number, Value};
+use std::{collections::HashMap, convert::From};
+
+impl From<serde_json::Number> for Number {
+	fn from(value: serde_json::Number) -> Self {
+		if value.is_f64() {
+			return Number::Decimal(value.as_f64().unwrap());
+		} else if value.is_i64() {
+			return Number::SignedInteger(value.as_i64().unwrap().into());
+		} else {
+			return Number::UnsignedInteger(value.as_u64().unwrap().into());
+		}
+	}
+}
+
+impl Into<serde_json::Number> for Number {
+	fn into(self) -> serde_json::Number {
+		match self {
+			Number::SignedInteger(s) => serde_json::Number::from(s),
+			Number::UnsignedInteger(u) => serde_json::Number::from(u),
+			Number::Decimal(d) => serde_json::Number::from_f64(d).unwrap(),
+		}
+	}
+}
+
+impl From<serde_json::Value> for Value {
+	fn from(v: serde_json::Value) -> Self {
+		match v {
+			serde_json::Value::Null => Value::Null,
+			serde_json::Value::Bool(b) => Value::Bool(b),
+			serde_json::Value::Number(n) => Value::Number(n.into()),
+			serde_json::Value::String(s) => Value::String(s),
+			serde_json::Value::Array(arr) => {
+				let mut vec: Vec<Value> = vec![];
+				for item in arr.into_iter() {
+					vec.push(item.into());
+				}
+				Value::Array(vec)
+			}
+			serde_json::Value::Object(map) => {
+				let mut hashmap: HashMap<String, Value> = HashMap::new();
+				for item in map.into_iter() {
+					hashmap.insert(item.0, item.1.into());
+				}
+				Value::Object(hashmap)
+			}
+		}
+	}
+}
+
+impl Into<serde_json::Value> for Value {
+	fn into(self) -> serde_json::Value {
+		match self {
+			Value::Null => serde_json::Value::Null,
+			Value::Bool(b) => serde_json::Value::Bool(b),
+			Value::Number(n) => serde_json::Value::Number(n.into()),
+			Value::String(s) => serde_json::Value::String(s),
+			Value::Array(arr) => {
+				let mut vec: Vec<serde_json::Value> = vec![];
+				for item in arr.into_iter() {
+					vec.push(item.into());
+				}
+				serde_json::Value::Array(vec)
+			}
+			Value::Object(hashmap) => {
+				let mut map: serde_json::Map<String, serde_json::Value> = serde_json::Map::new();
+				for item in hashmap.into_iter() {
+					map.insert(item.0, item.1.into());
+				}
+				serde_json::Value::Object(map)
+			}
+		}
+	}
+}

src/models/messages.rs

@@ -1,5 +1,4 @@
-use serde_json::{Map, Value};
-
+use crate::{models::Value, utils::request_types};
 use std::collections::HashMap;
 
 pub enum BaseMessage {
@@ -15,7 +14,7 @@ pub enum BaseMessage {
 	FunctionCallRequest {
 		request_id: String,
 		function: String,
-		arguments: Map<String, Value>,
+		arguments: HashMap<String, Value>,
 	},
 	FunctionCallResponse {
 		request_id: String,
@@ -55,8 +54,8 @@ pub enum BaseMessage {
 impl BaseMessage {
 	pub fn get_type(&self) -> u64 {
 		match &self {
-			BaseMessage::Unknown { .. } | BaseMessage::Error { .. } => 0,
-			BaseMessage::RegisterModuleRequest { .. } => 1,
+			BaseMessage::Unknown { .. } | BaseMessage::Error { .. } => request_types::ERROR,
+			BaseMessage::RegisterModuleRequest { .. } => request_types::MODULE_REGISTRATION,
 			BaseMessage::RegisterModuleResponse { .. } => 2,
 			BaseMessage::FunctionCallRequest { .. } => 3,
 			BaseMessage::FunctionCallResponse { .. } => 4,

src/models/mod.rs

@@ -1,3 +1,6 @@
+mod json_value;
 mod messages;
+mod value;
 
 pub use messages::BaseMessage;
+pub use value::{Number, Value};

src/models/value.rs

@@ -0,0 +1,18 @@
+use std::collections::HashMap;
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum Number {
+	SignedInteger(i64),
+	UnsignedInteger(u64),
+	Decimal(f64),
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum Value {
+	Null,
+	Bool(bool),
+	Number(Number),
+	String(String),
+	Array(Vec<Value>),
+	Object(HashMap<String, Value>),
+}

src/protocol/base_protocol.rs

@@ -1,12 +1,14 @@
+use crate::{
+	connection::Buffer,
+	models::{BaseMessage, Value},
+	protocol::json_protocol,
+};
+
 use std::{
 	collections::HashMap,
 	time::{SystemTime, UNIX_EPOCH},
 };
 
-use crate::{connection::Buffer, models::BaseMessage, protocol::json_protocol};
-
-use serde_json::{Map, Value};
-
 pub enum BaseProtocol {
 	JsonProtocol { module_id: String },
 	MsgPackProtocol { module_id: String },
@@ -87,15 +89,19 @@ impl BaseProtocol {
 		}
 	}
 
-	pub fn call_function(&self, function: String, arguments: Map<String, Value>) -> BaseMessage {
+	pub fn call_function(
+		&self,
+		function: String,
+		arguments: HashMap<String, Value>,
+	) -> BaseMessage {
 		BaseMessage::FunctionCallRequest {
 			request_id: self.generate_request_id(),
 			function,
 			arguments,
 		}
 	}
 
-	pub fn encode(&self, req: &BaseMessage) -> Buffer {
+	pub fn encode(&self, req: BaseMessage) -> Buffer {
 		match self {
 			BaseProtocol::JsonProtocol { .. } => json_protocol::encode(&self, req),
 			_ => panic!("Currently, only JsonProtocol is supported"),