From 807c9d142b8a5faa66bea7af019b865550b65ea6 Mon Sep 17 00:00:00 2001 From: BratSinot Date: Tue, 28 Dec 2021 12:11:40 +0200 Subject: [PATCH] Add hashbrown HashMap/HashSet implementations for Input/Output type. --- Cargo.toml | 1 + .../external/json_object/hashbrown_hashmap.rs | 111 ++++++++++++++++++ src/types/external/json_object/mod.rs | 2 + src/types/external/list/hashbrown_hash_set.rs | 76 ++++++++++++ src/types/external/list/mod.rs | 2 + 5 files changed, 192 insertions(+) create mode 100644 src/types/external/json_object/hashbrown_hashmap.rs create mode 100644 src/types/external/list/hashbrown_hash_set.rs diff --git a/Cargo.toml b/Cargo.toml index 08a5fa19..9c2b54e3 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -33,6 +33,7 @@ async-stream = "0.3.0" async-trait = "0.1.48" fnv = "1.0.7" futures-util = { version = "0.3.0", default-features = false, features = ["io", "sink"] } +hashbrown = { version="0.11.2", optional = true } indexmap = "1.6.2" once_cell = "1.7.2" pin-project-lite = "0.2.6" diff --git a/src/types/external/json_object/hashbrown_hashmap.rs b/src/types/external/json_object/hashbrown_hashmap.rs new file mode 100644 index 00000000..d853adf6 --- /dev/null +++ b/src/types/external/json_object/hashbrown_hashmap.rs @@ -0,0 +1,111 @@ +use std::borrow::Cow; +use std::fmt::Display; +use std::hash::Hash; +use std::str::FromStr; + +use async_graphql_parser::types::Field; +use async_graphql_parser::Positioned; +use async_graphql_value::{from_value, to_value}; +use hashbrown::HashMap; +use indexmap::IndexMap; +use serde::de::DeserializeOwned; +use serde::Serialize; + +use crate::registry::{MetaType, Registry}; +use crate::{ + ContextSelectionSet, InputType, InputValueError, InputValueResult, Name, OutputType, + ServerResult, Value, +}; + +impl InputType for HashMap + where + K: ToString + FromStr + Eq + Hash + Send + Sync, + K::Err: Display, + V: Serialize + DeserializeOwned + Send + Sync, +{ + type RawValueType = Self; + + fn type_name() -> Cow<'static, str> { + Cow::Borrowed("JSONObject") + } + + fn create_type_info(registry: &mut Registry) -> String { + registry.create_input_type::(|_| MetaType::Scalar { + name: ::type_name().to_string(), + description: Some("A scalar that can represent any JSON Object value."), + is_valid: |_| true, + visible: None, + specified_by_url: None, + }) + } + + fn parse(value: Option) -> InputValueResult { + let value = value.unwrap_or_default(); + match value { + Value::Object(map) => map + .into_iter() + .map(|(name, value)| { + Ok(( + K::from_str(&name).map_err(|err| { + InputValueError::::custom(format!("object key: {}", err)) + })?, + from_value(value).map_err(|err| format!("object value: {}", err))?, + )) + }) + .collect::>() + .map_err(InputValueError::propagate), + _ => Err(InputValueError::expected_type(value)), + } + } + + fn to_value(&self) -> Value { + let mut map = IndexMap::new(); + for (name, value) in self { + map.insert( + Name::new(name.to_string()), + to_value(value).unwrap_or_default(), + ); + } + Value::Object(map) + } + + fn as_raw_value(&self) -> Option<&Self::RawValueType> { + Some(self) + } +} + +#[async_trait::async_trait] +impl OutputType for HashMap + where + K: ToString + Eq + Hash + Send + Sync, + V: Serialize + Send + Sync, +{ + fn type_name() -> Cow<'static, str> { + Cow::Borrowed("JSONObject") + } + + fn create_type_info(registry: &mut Registry) -> String { + registry.create_output_type::(|_| MetaType::Scalar { + name: ::type_name().to_string(), + description: Some("A scalar that can represent any JSON Object value."), + is_valid: |_| true, + visible: None, + specified_by_url: None, + }) + } + + async fn resolve( + &self, + _ctx: &ContextSelectionSet<'_>, + _field: &Positioned, + ) -> ServerResult { + let mut map = IndexMap::new(); + for (name, value) in self { + map.insert( + Name::new(name.to_string()), + to_value(value).unwrap_or_default(), + ); + } + Ok(Value::Object(map)) + } +} diff --git a/src/types/external/json_object/mod.rs b/src/types/external/json_object/mod.rs index e579be5c..1a750794 100644 --- a/src/types/external/json_object/mod.rs +++ b/src/types/external/json_object/mod.rs @@ -1,2 +1,4 @@ mod btreemap; +#[cfg(feature = "hashbrown")] +mod hashbrown_hashmap; mod hashmap; diff --git a/src/types/external/list/hashbrown_hash_set.rs b/src/types/external/list/hashbrown_hash_set.rs new file mode 100644 index 00000000..98dfde2b --- /dev/null +++ b/src/types/external/list/hashbrown_hash_set.rs @@ -0,0 +1,76 @@ +use std::borrow::Cow; +use std::cmp::Eq; +use std::hash::Hash; + +use hashbrown::HashSet; + +use crate::parser::types::Field; +use crate::resolver_utils::resolve_list; +use crate::{ + registry, ContextSelectionSet, InputType, InputValueError, InputValueResult, OutputType, + Positioned, Result, ServerResult, Value, +}; + +impl InputType for HashSet { + type RawValueType = Self; + + fn type_name() -> Cow<'static, str> { + Cow::Owned(format!("[{}]", T::qualified_type_name())) + } + + fn qualified_type_name() -> String { + format!("[{}]!", T::qualified_type_name()) + } + + fn create_type_info(registry: &mut registry::Registry) -> String { + T::create_type_info(registry); + Self::qualified_type_name() + } + + fn parse(value: Option) -> InputValueResult { + match value.unwrap_or_default() { + Value::List(values) => values + .into_iter() + .map(|value| InputType::parse(Some(value))) + .collect::>() + .map_err(InputValueError::propagate), + value => Ok({ + let mut result = Self::default(); + result.insert(InputType::parse(Some(value)).map_err(InputValueError::propagate)?); + result + }), + } + } + + fn to_value(&self) -> Value { + Value::List(self.iter().map(InputType::to_value).collect()) + } + + fn as_raw_value(&self) -> Option<&Self::RawValueType> { + Some(self) + } +} + +#[async_trait::async_trait] +impl OutputType for HashSet { + fn type_name() -> Cow<'static, str> { + Cow::Owned(format!("[{}]", T::qualified_type_name())) + } + + fn qualified_type_name() -> String { + format!("[{}]!", T::qualified_type_name()) + } + + fn create_type_info(registry: &mut registry::Registry) -> String { + T::create_type_info(registry); + Self::qualified_type_name() + } + + async fn resolve( + &self, + ctx: &ContextSelectionSet<'_>, + field: &Positioned, + ) -> ServerResult { + resolve_list(ctx, field, self, Some(self.len())).await + } +} diff --git a/src/types/external/list/mod.rs b/src/types/external/list/mod.rs index ad015fe3..d80bb0c6 100644 --- a/src/types/external/list/mod.rs +++ b/src/types/external/list/mod.rs @@ -1,6 +1,8 @@ mod array; mod btree_set; mod hash_set; +#[cfg(feature = "hashbrown")] +mod hashbrown_hash_set; mod linked_list; mod slice; mod vec;