Struct bluejay_parser::ast::definition::SchemaDefinition

pub struct SchemaDefinition<'a, C: Context = DefaultContext> { /* private fields */ }

Trait Implementations

impl<'a, C: Debug + Context> Debug for SchemaDefinition<'a, C>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a, C: Context> HasDirectives for SchemaDefinition<'a, C>

type Directives = Directives<'a, C>

fn directives(&self) -> Option<&Self::Directives>

impl<'a, C: Context> SchemaDefinition for SchemaDefinition<'a, C>

type Directive = Directive<'a, C>

type Directives = Directives<'a, C>

type InputValueDefinition = InputValueDefinition<'a, C>

type InputFieldsDefinition = InputFieldsDefinition<'a, C>

type ArgumentsDefinition = ArgumentsDefinition<'a, C>

type EnumValueDefinition = EnumValueDefinition<'a, C>

type EnumValueDefinitions = EnumValueDefinitions<'a, C>

type FieldDefinition = FieldDefinition<'a, C>

type FieldsDefinition = FieldsDefinition<'a, C>

type InterfaceImplementation = InterfaceImplementation<'a, C>

type InterfaceImplementations = InterfaceImplementations<'a, C>

type UnionMemberType = UnionMemberType<'a, C>

type UnionMemberTypes = UnionMemberTypes<'a, C>

type InputType = InputType<'a, C>

type OutputType = OutputType<'a, C>

type CustomScalarTypeDefinition = CustomScalarTypeDefinition<'a, C>

type ObjectTypeDefinition = ObjectTypeDefinition<'a, C>

type InterfaceTypeDefinition = InterfaceTypeDefinition<'a, C>

type UnionTypeDefinition = UnionTypeDefinition<'a, C>

type InputObjectTypeDefinition = InputObjectTypeDefinition<'a, C>

type EnumTypeDefinition = EnumTypeDefinition<'a, C>

type TypeDefinition = TypeDefinition<'a, C>

type DirectiveDefinition = DirectiveDefinition<'a, C>

type TypeDefinitions<'b> = Map<Values<'b, &'b str, &'b TypeDefinition<'a, C>>, fn(_: &&'b TypeDefinition<'a, C>) -> TypeDefinitionReference<'b, TypeDefinition<'a, C>>> where 'a: 'b

type DirectiveDefinitions<'b> = Copied<Values<'b, &'b str, &'b DirectiveDefinition<'a, C>>> where 'a: 'b

type InterfaceImplementors<'b> = Flatten<IntoIter<Copied<Iter<'b, &'b ObjectTypeDefinition<'a, C>>>>> where 'a: 'b

fn description(&self) -> Option<&str>

fn query(&self) -> &Self::ObjectTypeDefinition

fn mutation(&self) -> Option<&Self::ObjectTypeDefinition>

fn subscription(&self) -> Option<&Self::ObjectTypeDefinition>

fn get_type_definition( &self, name: &str ) -> Option<TypeDefinitionReference<'_, Self::TypeDefinition>>

fn type_definitions(&self) -> Self::TypeDefinitions<'_>

fn get_directive_definition( &self, name: &str ) -> Option<&Self::DirectiveDefinition>

fn directive_definitions(&self) -> Self::DirectiveDefinitions<'_>

fn get_interface_implementors( &self, itd: &Self::InterfaceTypeDefinition ) -> Self::InterfaceImplementors<'_>

impl<'a, C: Context> TryFrom<&'a DefinitionDocument<'a, C>> for SchemaDefinition<'a, C>

type Error = Vec<DefinitionDocumentError<'a, C>>

The type returned in the event of a conversion error.

fn try_from( definition_document: &'a DefinitionDocument<'a, C> ) -> Result<Self, Self::Error>

Performs the conversion.