use std::marker::PhantomData;
use super::*;
use crate::graphql::carrier::Builtin;
pub struct BytesFilter<B, I = Builtin> {
pub(crate) eq: Option<B>,
pub(crate) ne: Option<B>,
pub(crate) gt: Option<B>,
pub(crate) gte: Option<B>,
pub(crate) lt: Option<B>,
pub(crate) lte: Option<B>,
pub(crate) contains: Option<B>,
pub(crate) not_contains: Option<B>,
pub(crate) in_: Option<Box<[B]>>,
pub(crate) not_in: Option<Box<[B]>>,
pub(crate) wire: PhantomData<fn() -> I>,
}
impl<B, I> BytesFilter<B, I> {
#[inline]
pub const fn new() -> Self {
Self {
eq: None,
ne: None,
gt: None,
gte: None,
lt: None,
lte: None,
contains: None,
not_contains: None,
in_: None,
not_in: None,
wire: PhantomData,
}
}
#[inline]
pub const fn is_empty(&self) -> bool {
self.eq.is_none()
&& self.ne.is_none()
&& self.gt.is_none()
&& self.gte.is_none()
&& self.lt.is_none()
&& self.lte.is_none()
&& self.contains.is_none()
&& self.not_contains.is_none()
&& self.in_.is_none()
&& self.not_in.is_none()
}
opt_accessor!(eq: B => with_eq, set_eq, maybe_eq, update_eq);
opt_accessor!(ne: B => with_ne, set_ne, maybe_ne, update_ne);
opt_accessor!(gt: B => with_gt, set_gt, maybe_gt, update_gt);
opt_accessor!(gte: B => with_gte, set_gte, maybe_gte, update_gte);
opt_accessor!(lt: B => with_lt, set_lt, maybe_lt, update_lt);
opt_accessor!(lte: B => with_lte, set_lte, maybe_lte, update_lte);
opt_accessor!(contains: B => with_contains, set_contains, maybe_contains, update_contains);
opt_accessor!(
not_contains: B => with_not_contains, set_not_contains, maybe_not_contains, update_not_contains
);
opt_accessor!(in_: [B] => with_in_, set_in_, maybe_in_, update_in_);
opt_accessor!(not_in: [B] => with_not_in, set_not_in, maybe_not_in, update_not_in);
#[inline]
pub const fn is_referential(&self) -> bool {
(self.eq.is_some() ^ self.in_.is_some())
&& self.ne.is_none()
&& self.gt.is_none()
&& self.gte.is_none()
&& self.lt.is_none()
&& self.lte.is_none()
&& self.contains.is_none()
&& self.not_contains.is_none()
&& self.not_in.is_none()
}
pub fn try_map<C, E, F>(self, mut f: F) -> Result<BytesFilter<C, I>, E>
where
F: FnMut(B) -> Result<C, E>,
{
Ok(BytesFilter {
eq: map_operand(self.eq, &mut f)?,
ne: map_operand(self.ne, &mut f)?,
gt: map_operand(self.gt, &mut f)?,
gte: map_operand(self.gte, &mut f)?,
lt: map_operand(self.lt, &mut f)?,
lte: map_operand(self.lte, &mut f)?,
contains: map_operand(self.contains, &mut f)?,
not_contains: map_operand(self.not_contains, &mut f)?,
in_: map_operands(self.in_, &mut f)?,
not_in: map_operands(self.not_in, &mut f)?,
wire: PhantomData,
})
}
}
impl<B, I> Default for BytesFilter<B, I> {
#[inline]
fn default() -> Self {
Self::new()
}
}
impl<B, C, I> TryMapFilter<B, C> for BytesFilter<B, I> {
type Mapped = BytesFilter<C, I>;
#[inline]
fn try_map_filter<E, F>(self, f: F) -> Result<Self::Mapped, E>
where
F: FnMut(B) -> Result<C, E>,
{
self.try_map(f)
}
}
impl<B, I> EqualsFilter<B> for BytesFilter<B, I> {
#[inline]
fn equals(value: B) -> Self {
Self::new().with_eq(value)
}
}
impl<B, I> GraphqlFilter for BytesFilter<B, I> {
#[inline]
fn is_empty(&self) -> bool {
Self::is_empty(self)
}
}
impl<B: core::fmt::Debug, I> core::fmt::Debug for BytesFilter<B, I> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.debug_struct("BytesFilter")
.field("eq", &self.eq)
.field("ne", &self.ne)
.field("gt", &self.gt)
.field("gte", &self.gte)
.field("lt", &self.lt)
.field("lte", &self.lte)
.field("contains", &self.contains)
.field("not_contains", &self.not_contains)
.field("in_", &self.in_)
.field("not_in", &self.not_in)
.finish()
}
}
impl<B: Clone, I> Clone for BytesFilter<B, I> {
fn clone(&self) -> Self {
Self {
eq: self.eq.clone(),
ne: self.ne.clone(),
gt: self.gt.clone(),
gte: self.gte.clone(),
lt: self.lt.clone(),
lte: self.lte.clone(),
contains: self.contains.clone(),
not_contains: self.not_contains.clone(),
in_: self.in_.clone(),
not_in: self.not_in.clone(),
wire: PhantomData,
}
}
}
impl<B: PartialEq, I> PartialEq for BytesFilter<B, I> {
fn eq(&self, other: &Self) -> bool {
self.eq == other.eq
&& self.ne == other.ne
&& self.gt == other.gt
&& self.gte == other.gte
&& self.lt == other.lt
&& self.lte == other.lte
&& self.contains == other.contains
&& self.not_contains == other.not_contains
&& self.in_ == other.in_
&& self.not_in == other.not_in
}
}
pub struct FixedBytesFilter<B, const N: usize, I = Builtin> {
pub(crate) eq: Option<B>,
pub(crate) ne: Option<B>,
pub(crate) gt: Option<B>,
pub(crate) gte: Option<B>,
pub(crate) lt: Option<B>,
pub(crate) lte: Option<B>,
pub(crate) in_: Option<Box<[B]>>,
pub(crate) not_in: Option<Box<[B]>>,
pub(crate) wire: PhantomData<fn() -> I>,
}
impl<B, const N: usize, I> FixedBytesFilter<B, N, I> {
#[inline]
pub const fn new() -> Self {
Self {
eq: None,
ne: None,
gt: None,
gte: None,
lt: None,
lte: None,
in_: None,
not_in: None,
wire: PhantomData,
}
}
#[inline]
pub const fn is_empty(&self) -> bool {
self.eq.is_none()
&& self.ne.is_none()
&& self.gt.is_none()
&& self.gte.is_none()
&& self.lt.is_none()
&& self.lte.is_none()
&& self.in_.is_none()
&& self.not_in.is_none()
}
opt_accessor!(eq: B => with_eq, set_eq, maybe_eq, update_eq);
opt_accessor!(ne: B => with_ne, set_ne, maybe_ne, update_ne);
opt_accessor!(gt: B => with_gt, set_gt, maybe_gt, update_gt);
opt_accessor!(gte: B => with_gte, set_gte, maybe_gte, update_gte);
opt_accessor!(lt: B => with_lt, set_lt, maybe_lt, update_lt);
opt_accessor!(lte: B => with_lte, set_lte, maybe_lte, update_lte);
opt_accessor!(in_: [B] => with_in_, set_in_, maybe_in_, update_in_);
opt_accessor!(not_in: [B] => with_not_in, set_not_in, maybe_not_in, update_not_in);
#[inline]
pub const fn is_referential(&self) -> bool {
(self.eq.is_some() ^ self.in_.is_some())
&& self.ne.is_none()
&& self.gt.is_none()
&& self.gte.is_none()
&& self.lt.is_none()
&& self.lte.is_none()
&& self.not_in.is_none()
}
pub fn try_map<C, E, F>(self, mut f: F) -> Result<FixedBytesFilter<C, N, I>, E>
where
F: FnMut(B) -> Result<C, E>,
{
Ok(FixedBytesFilter {
eq: map_operand(self.eq, &mut f)?,
ne: map_operand(self.ne, &mut f)?,
gt: map_operand(self.gt, &mut f)?,
gte: map_operand(self.gte, &mut f)?,
lt: map_operand(self.lt, &mut f)?,
lte: map_operand(self.lte, &mut f)?,
in_: map_operands(self.in_, &mut f)?,
not_in: map_operands(self.not_in, &mut f)?,
wire: PhantomData,
})
}
}
impl<B, const N: usize, I> Default for FixedBytesFilter<B, N, I> {
#[inline]
fn default() -> Self {
Self::new()
}
}
impl<B, C, const N: usize, I> TryMapFilter<B, C> for FixedBytesFilter<B, N, I> {
type Mapped = FixedBytesFilter<C, N, I>;
#[inline]
fn try_map_filter<E, F>(self, f: F) -> Result<Self::Mapped, E>
where
F: FnMut(B) -> Result<C, E>,
{
self.try_map(f)
}
}
impl<B, const N: usize, I> EqualsFilter<B> for FixedBytesFilter<B, N, I> {
#[inline]
fn equals(value: B) -> Self {
Self::new().with_eq(value)
}
}
impl<B, const N: usize, I> GraphqlFilter for FixedBytesFilter<B, N, I> {
#[inline]
fn is_empty(&self) -> bool {
Self::is_empty(self)
}
}
impl<B: core::fmt::Debug, const N: usize, I> core::fmt::Debug for FixedBytesFilter<B, N, I> {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.debug_struct("FixedBytesFilter")
.field("eq", &self.eq)
.field("ne", &self.ne)
.field("gt", &self.gt)
.field("gte", &self.gte)
.field("lt", &self.lt)
.field("lte", &self.lte)
.field("in_", &self.in_)
.field("not_in", &self.not_in)
.finish()
}
}
impl<B: Clone, const N: usize, I> Clone for FixedBytesFilter<B, N, I> {
fn clone(&self) -> Self {
Self {
eq: self.eq.clone(),
ne: self.ne.clone(),
gt: self.gt.clone(),
gte: self.gte.clone(),
lt: self.lt.clone(),
lte: self.lte.clone(),
in_: self.in_.clone(),
not_in: self.not_in.clone(),
wire: PhantomData,
}
}
}
impl<B: PartialEq, const N: usize, I> PartialEq for FixedBytesFilter<B, N, I> {
fn eq(&self, other: &Self) -> bool {
self.eq == other.eq
&& self.ne == other.ne
&& self.gt == other.gt
&& self.gte == other.gte
&& self.lt == other.lt
&& self.lte == other.lte
&& self.in_ == other.in_
&& self.not_in == other.not_in
}
}
#[cfg(any(feature = "mongo", feature = "sqlx"))]
pub(crate) struct ByteOperands<B> {
pub(crate) eq: Option<B>,
pub(crate) ne: Option<B>,
pub(crate) gt: Option<B>,
pub(crate) gte: Option<B>,
pub(crate) lt: Option<B>,
pub(crate) lte: Option<B>,
#[cfg_attr(
not(feature = "sqlx"),
expect(
dead_code,
reason = "only the SQL crossing carries the substring pair; see above"
)
)]
pub(crate) contains: Option<B>,
#[cfg_attr(
not(feature = "sqlx"),
expect(
dead_code,
reason = "only the SQL crossing carries the substring pair; see above"
)
)]
pub(crate) not_contains: Option<B>,
pub(crate) in_: Option<Box<[B]>>,
pub(crate) not_in: Option<Box<[B]>>,
}
#[cfg(any(feature = "mongo", feature = "sqlx"))]
pub(crate) trait ByteSlots<B> {
fn byte_operands(self) -> ByteOperands<B>;
}
#[cfg(any(feature = "mongo", feature = "sqlx"))]
impl<B, I> ByteSlots<B> for BytesFilter<B, I> {
#[inline]
fn byte_operands(self) -> ByteOperands<B> {
ByteOperands {
eq: self.eq,
ne: self.ne,
gt: self.gt,
gte: self.gte,
lt: self.lt,
lte: self.lte,
contains: self.contains,
not_contains: self.not_contains,
in_: self.in_,
not_in: self.not_in,
}
}
}
#[cfg(any(feature = "mongo", feature = "sqlx"))]
impl<B, const N: usize, I> ByteSlots<B> for FixedBytesFilter<B, N, I> {
#[inline]
fn byte_operands(self) -> ByteOperands<B> {
ByteOperands {
eq: self.eq,
ne: self.ne,
gt: self.gt,
gte: self.gte,
lt: self.lt,
lte: self.lte,
contains: None,
not_contains: None,
in_: self.in_,
not_in: self.not_in,
}
}
}
#[cfg(feature = "async-graphql")]
fn bytes_fields<B, I>(
registry: &mut async_graphql::registry::Registry,
) -> async_graphql::indexmap::IndexMap<::std::string::String, async_graphql::registry::MetaInputValue>
where
I: crate::BytesWire<B>,
I::Carrier: async_graphql::InputType,
{
__ingraph_filter_input_fields!(
registry,
"eq" : ::core::option::Option<<I as crate::BytesWire<B>>::Carrier>,
"ne" : ::core::option::Option<<I as crate::BytesWire<B>>::Carrier>,
"gt" : ::core::option::Option<<I as crate::BytesWire<B>>::Carrier>,
"gte" : ::core::option::Option<<I as crate::BytesWire<B>>::Carrier>,
"lt" : ::core::option::Option<<I as crate::BytesWire<B>>::Carrier>,
"lte" : ::core::option::Option<<I as crate::BytesWire<B>>::Carrier>,
"contains" : ::core::option::Option<<I as crate::BytesWire<B>>::Carrier>,
"notContains" : ::core::option::Option<<I as crate::BytesWire<B>>::Carrier>,
"in" : ::core::option::Option<::std::boxed::Box<[<I as crate::BytesWire<B>>::Carrier]>>,
"notIn" : ::core::option::Option<::std::boxed::Box<[<I as crate::BytesWire<B>>::Carrier]>>,
)
}
#[cfg(feature = "async-graphql")]
fn bytes_values<B, I>(
filter: &BytesFilter<B, I>,
) -> async_graphql::indexmap::IndexMap<async_graphql::Name, async_graphql::Value>
where
I: crate::BytesWire<B>,
I::Carrier: async_graphql::InputType,
{
let mut map = async_graphql::indexmap::IndexMap::new();
map.insert(
async_graphql::Name::new("eq"),
via::carried(&filter.eq, I::carry),
);
map.insert(
async_graphql::Name::new("ne"),
via::carried(&filter.ne, I::carry),
);
map.insert(
async_graphql::Name::new("gt"),
via::carried(&filter.gt, I::carry),
);
map.insert(
async_graphql::Name::new("gte"),
via::carried(&filter.gte, I::carry),
);
map.insert(
async_graphql::Name::new("lt"),
via::carried(&filter.lt, I::carry),
);
map.insert(
async_graphql::Name::new("lte"),
via::carried(&filter.lte, I::carry),
);
map.insert(
async_graphql::Name::new("contains"),
via::carried(&filter.contains, I::carry),
);
map.insert(
async_graphql::Name::new("notContains"),
via::carried(&filter.not_contains, I::carry),
);
map.insert(
async_graphql::Name::new("in"),
via::carried_list(&filter.in_, I::carry),
);
map.insert(
async_graphql::Name::new("notIn"),
via::carried_list(&filter.not_in, I::carry),
);
map
}
#[cfg(feature = "async-graphql")]
fn fixed_bytes_fields<B, I>(
registry: &mut async_graphql::registry::Registry,
) -> async_graphql::indexmap::IndexMap<::std::string::String, async_graphql::registry::MetaInputValue>
where
I: crate::BytesWire<B>,
I::Carrier: async_graphql::InputType,
{
__ingraph_filter_input_fields!(
registry,
"eq" : ::core::option::Option<<I as crate::BytesWire<B>>::Carrier>,
"ne" : ::core::option::Option<<I as crate::BytesWire<B>>::Carrier>,
"gt" : ::core::option::Option<<I as crate::BytesWire<B>>::Carrier>,
"gte" : ::core::option::Option<<I as crate::BytesWire<B>>::Carrier>,
"lt" : ::core::option::Option<<I as crate::BytesWire<B>>::Carrier>,
"lte" : ::core::option::Option<<I as crate::BytesWire<B>>::Carrier>,
"in" : ::core::option::Option<::std::boxed::Box<[<I as crate::BytesWire<B>>::Carrier]>>,
"notIn" : ::core::option::Option<::std::boxed::Box<[<I as crate::BytesWire<B>>::Carrier]>>,
)
}
#[cfg(feature = "async-graphql")]
fn fixed_bytes_values<B, const N: usize, I>(
filter: &FixedBytesFilter<B, N, I>,
) -> async_graphql::indexmap::IndexMap<async_graphql::Name, async_graphql::Value>
where
I: crate::BytesWire<B>,
I::Carrier: async_graphql::InputType,
{
let mut map = async_graphql::indexmap::IndexMap::new();
map.insert(
async_graphql::Name::new("eq"),
via::carried(&filter.eq, I::carry),
);
map.insert(
async_graphql::Name::new("ne"),
via::carried(&filter.ne, I::carry),
);
map.insert(
async_graphql::Name::new("gt"),
via::carried(&filter.gt, I::carry),
);
map.insert(
async_graphql::Name::new("gte"),
via::carried(&filter.gte, I::carry),
);
map.insert(
async_graphql::Name::new("lt"),
via::carried(&filter.lt, I::carry),
);
map.insert(
async_graphql::Name::new("lte"),
via::carried(&filter.lte, I::carry),
);
map.insert(
async_graphql::Name::new("in"),
via::carried_list(&filter.in_, I::carry),
);
map.insert(
async_graphql::Name::new("notIn"),
via::carried_list(&filter.not_in, I::carry),
);
map
}
#[cfg(feature = "async-graphql")]
impl<B, I> async_graphql::InputType for BytesFilter<B, I>
where
B: Send + Sync,
I: crate::BytesWire<B>,
I::Carrier: async_graphql::InputType,
{
type RawValueType = Self;
#[inline]
fn type_name() -> ::std::borrow::Cow<'static, str> {
::std::borrow::Cow::Borrowed(<I as crate::BytesWire<B>>::NAME)
}
fn create_type_info(registry: &mut async_graphql::registry::Registry) -> ::std::string::String {
registry.create_input_type::<Self, _>(
async_graphql::registry::MetaTypeId::InputObject,
|registry| async_graphql::registry::MetaType::InputObject {
name: ::std::borrow::Cow::into_owned(<Self as async_graphql::InputType>::type_name()),
description: ::std::option::Option::None,
input_fields: bytes_fields::<B, I>(registry),
visible: ::std::option::Option::None,
inaccessible: false,
tags: ::std::vec::Vec::new(),
rust_typename: ::std::option::Option::Some(::std::any::type_name::<Self>()),
oneof: false,
directive_invocations: ::std::vec::Vec::new(),
},
)
}
fn parse(
value: ::std::option::Option<async_graphql::Value>,
) -> async_graphql::InputValueResult<Self> {
let object = match super::sent(value) {
super::Sent::Longhand(object) => object,
super::Sent::Bare(bare) => {
let mut object = async_graphql::indexmap::IndexMap::new();
object.insert(async_graphql::Name::new("eq"), bare);
object
}
super::Sent::Null => {
return ::std::result::Result::Err(async_graphql::InputValueError::expected_type(
async_graphql::Value::Null,
));
}
super::Sent::Refused(sent) => {
return ::std::result::Result::Err(async_graphql::InputValueError::expected_type(sent));
}
};
::std::result::Result::Ok(Self {
eq: via::crossed::<_, _, _, Self>(&object, "eq", I::cross)?,
ne: via::crossed::<_, _, _, Self>(&object, "ne", I::cross)?,
gt: via::crossed::<_, _, _, Self>(&object, "gt", I::cross)?,
gte: via::crossed::<_, _, _, Self>(&object, "gte", I::cross)?,
lt: via::crossed::<_, _, _, Self>(&object, "lt", I::cross)?,
lte: via::crossed::<_, _, _, Self>(&object, "lte", I::cross)?,
contains: via::crossed::<_, _, _, Self>(&object, "contains", I::cross)?,
not_contains: via::crossed::<_, _, _, Self>(&object, "notContains", I::cross)?,
in_: via::crossed_list::<_, _, _, Self>(&object, "in", I::cross)?,
not_in: via::crossed_list::<_, _, _, Self>(&object, "notIn", I::cross)?,
wire: PhantomData,
})
}
fn to_value(&self) -> async_graphql::Value {
async_graphql::Value::Object(bytes_values::<B, I>(self))
}
#[inline]
fn as_raw_value(&self) -> ::std::option::Option<&Self::RawValueType> {
::std::option::Option::Some(self)
}
}
#[cfg(feature = "async-graphql")]
impl<B, I> async_graphql::InputObjectType for BytesFilter<B, I>
where
B: Send + Sync,
I: crate::BytesWire<B>,
I::Carrier: async_graphql::InputType,
{
}
#[cfg(feature = "async-graphql")]
impl<B, I> crate::NullableFace for BytesFilter<B, I>
where
B: Send + Sync,
I: crate::BytesWire<B>,
I::Carrier: async_graphql::InputType,
{
fn bare_fields(
registry: &mut async_graphql::registry::Registry,
) -> async_graphql::indexmap::IndexMap<
::std::string::String,
async_graphql::registry::MetaInputValue,
> {
bytes_fields::<B, I>(registry)
}
fn bare_values(
&self,
) -> async_graphql::indexmap::IndexMap<async_graphql::Name, async_graphql::Value> {
bytes_values::<B, I>(self)
}
}
#[cfg(feature = "async-graphql")]
impl<B, const N: usize, I> async_graphql::InputType for FixedBytesFilter<B, N, I>
where
B: Send + Sync,
I: crate::BytesWire<B>,
I::Carrier: async_graphql::InputType,
{
type RawValueType = Self;
#[inline]
fn type_name() -> ::std::borrow::Cow<'static, str> {
::std::borrow::Cow::Owned(::std::format!(
"Fixed{N}{}",
<I as crate::BytesWire<B>>::NAME
))
}
fn create_type_info(registry: &mut async_graphql::registry::Registry) -> ::std::string::String {
registry.create_input_type::<Self, _>(
async_graphql::registry::MetaTypeId::InputObject,
|registry| async_graphql::registry::MetaType::InputObject {
name: ::std::borrow::Cow::into_owned(<Self as async_graphql::InputType>::type_name()),
description: ::std::option::Option::None,
input_fields: fixed_bytes_fields::<B, I>(registry),
visible: ::std::option::Option::None,
inaccessible: false,
tags: ::std::vec::Vec::new(),
rust_typename: ::std::option::Option::Some(::std::any::type_name::<Self>()),
oneof: false,
directive_invocations: ::std::vec::Vec::new(),
},
)
}
fn parse(
value: ::std::option::Option<async_graphql::Value>,
) -> async_graphql::InputValueResult<Self> {
let object = match super::sent(value) {
super::Sent::Longhand(object) => object,
super::Sent::Bare(bare) => {
let mut object = async_graphql::indexmap::IndexMap::new();
object.insert(async_graphql::Name::new("eq"), bare);
object
}
super::Sent::Null => {
return ::std::result::Result::Err(async_graphql::InputValueError::expected_type(
async_graphql::Value::Null,
));
}
super::Sent::Refused(sent) => {
return ::std::result::Result::Err(async_graphql::InputValueError::expected_type(sent));
}
};
::std::result::Result::Ok(Self {
eq: via::crossed::<_, _, _, Self>(&object, "eq", I::cross)?,
ne: via::crossed::<_, _, _, Self>(&object, "ne", I::cross)?,
gt: via::crossed::<_, _, _, Self>(&object, "gt", I::cross)?,
gte: via::crossed::<_, _, _, Self>(&object, "gte", I::cross)?,
lt: via::crossed::<_, _, _, Self>(&object, "lt", I::cross)?,
lte: via::crossed::<_, _, _, Self>(&object, "lte", I::cross)?,
in_: via::crossed_list::<_, _, _, Self>(&object, "in", I::cross)?,
not_in: via::crossed_list::<_, _, _, Self>(&object, "notIn", I::cross)?,
wire: PhantomData,
})
}
fn to_value(&self) -> async_graphql::Value {
async_graphql::Value::Object(fixed_bytes_values::<B, N, I>(self))
}
#[inline]
fn as_raw_value(&self) -> ::std::option::Option<&Self::RawValueType> {
::std::option::Option::Some(self)
}
}
#[cfg(feature = "async-graphql")]
impl<B, const N: usize, I> async_graphql::InputObjectType for FixedBytesFilter<B, N, I>
where
B: Send + Sync,
I: crate::BytesWire<B>,
I::Carrier: async_graphql::InputType,
{
}
#[cfg(feature = "async-graphql")]
impl<B, const N: usize, I> crate::NullableFace for FixedBytesFilter<B, N, I>
where
B: Send + Sync,
I: crate::BytesWire<B>,
I::Carrier: async_graphql::InputType,
{
fn bare_fields(
registry: &mut async_graphql::registry::Registry,
) -> async_graphql::indexmap::IndexMap<
::std::string::String,
async_graphql::registry::MetaInputValue,
> {
fixed_bytes_fields::<B, I>(registry)
}
fn bare_values(
&self,
) -> async_graphql::indexmap::IndexMap<async_graphql::Name, async_graphql::Value> {
fixed_bytes_values::<B, N, I>(self)
}
}