Struct SchemaDefinition 

pub struct SchemaDefinition<'a, S: SchemaDefinition, W: Warden<SchemaDefinition = S>> { /* private fields */ }

Implementations

impl<'a, S: SchemaDefinition, W: Warden<SchemaDefinition = S>> SchemaDefinition<'a, S, W>

pub fn new( cache: &'a Cache<'a, S, W>, ) -> Result<Self, SchemaDefinitionError<'a>>

pub fn inner(&self) -> &'a S

pub fn cache(&self) -> &'a Cache<'a, S, W>

Trait Implementations

impl<'a, S: SchemaDefinition + 'a, W: Warden<SchemaDefinition = S>> HasDirectives for SchemaDefinition<'a, S, W>

type Directives = Directives<'a, S, W>

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

impl<'a, S: SchemaDefinition + 'a, W: Warden<SchemaDefinition = S>> SchemaDefinition for SchemaDefinition<'a, S, W>

type Directive = Directive<'a, S, W>

type Directives = Directives<'a, S, W>

type InputValueDefinition = InputValueDefinition<'a, S, W>

type InputFieldsDefinition = InputFieldsDefinition<'a, S, W>

type ArgumentsDefinition = ArgumentsDefinition<'a, S, W>

type EnumValueDefinition = EnumValueDefinition<'a, S, W>

type EnumValueDefinitions = EnumValueDefinitions<'a, S, W>

type FieldDefinition = FieldDefinition<'a, S, W>

type FieldsDefinition = FieldsDefinition<'a, S, W>

type InterfaceImplementation = InterfaceImplementation<'a, S, W>

type InterfaceImplementations = InterfaceImplementations<'a, S, W>

type UnionMemberType = UnionMemberType<'a, S, W>

type UnionMemberTypes = UnionMemberTypes<'a, S, W>

type InputType = InputType<'a, S, W>

type OutputType = OutputType<'a, S, W>

type CustomScalarTypeDefinition = ScalarTypeDefinition<'a, S, W>

type ObjectTypeDefinition = ObjectTypeDefinition<'a, S, W>

type InterfaceTypeDefinition = InterfaceTypeDefinition<'a, S, W>

type UnionTypeDefinition = UnionTypeDefinition<'a, S, W>

type InputObjectTypeDefinition = InputObjectTypeDefinition<'a, S, W>

type EnumTypeDefinition = EnumTypeDefinition<'a, S, W>

type TypeDefinition = TypeDefinition<'a, S, W>

type DirectiveDefinition = DirectiveDefinition<'a, S, W>

type TypeDefinitions<'b> = Copied<Values<'b, &'a str, TypeDefinitionReference<'b, <SchemaDefinition<'a, S, W> as SchemaDefinition>::TypeDefinition>>> where 'a: 'b

type DirectiveDefinitions<'b> = Copied<Values<'b, &'a str, &'b <SchemaDefinition<'a, S, W> as SchemaDefinition>::DirectiveDefinition>> where 'a: 'b

type InterfaceImplementors<'b> = Copied<Iter<'b, &'b <SchemaDefinition<'a, S, W> as SchemaDefinition>::ObjectTypeDefinition>> 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 type_definitions(&self) -> Self::TypeDefinitions<'_>

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

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

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

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