cynic_parser/type_system/
definitions.rs

1use crate::AstLookup;
2
3use super::{
4    ids::*,
5    iter::{IdReader, Iter},
6    DefinitionId, Description, Directive, DirectiveDefinition, EnumDefinition,
7    InputObjectDefinition, InterfaceDefinition, ObjectDefinition, ScalarDefinition,
8    SchemaDefinition, TypeSystemId, UnionDefinition,
9};
10
11#[derive(Clone, Copy)]
12pub enum DefinitionRecord {
13    Schema(SchemaDefinitionId),
14    Scalar(ScalarDefinitionId),
15    Object(ObjectDefinitionId),
16    Interface(InterfaceDefinitionId),
17    Union(UnionDefinitionId),
18    Enum(EnumDefinitionId),
19    InputObject(InputObjectDefinitionId),
20    SchemaExtension(SchemaDefinitionId),
21    ScalarExtension(ScalarDefinitionId),
22    ObjectExtension(ObjectDefinitionId),
23    InterfaceExtension(InterfaceDefinitionId),
24    UnionExtension(UnionDefinitionId),
25    EnumExtension(EnumDefinitionId),
26    InputObjectExtension(InputObjectDefinitionId),
27    Directive(DirectiveDefinitionId),
28}
29
30#[derive(Clone, Copy)]
31pub enum Definition<'a> {
32    Schema(SchemaDefinition<'a>),
33    SchemaExtension(SchemaDefinition<'a>),
34    Type(TypeDefinition<'a>),
35    TypeExtension(TypeDefinition<'a>),
36    Directive(DirectiveDefinition<'a>),
37}
38
39impl Definition<'_> {
40    pub fn span(&self) -> crate::Span {
41        match self {
42            Definition::Schema(def) | Definition::SchemaExtension(def) => def.span(),
43            Definition::Type(ty) | Definition::TypeExtension(ty) => ty.span(),
44            Definition::Directive(def) => def.span(),
45        }
46    }
47}
48
49#[derive(Clone, Copy)]
50pub enum TypeDefinition<'a> {
51    Scalar(ScalarDefinition<'a>),
52    Object(ObjectDefinition<'a>),
53    Interface(InterfaceDefinition<'a>),
54    Union(UnionDefinition<'a>),
55    Enum(EnumDefinition<'a>),
56    InputObject(InputObjectDefinition<'a>),
57}
58
59impl<'a> TypeDefinition<'a> {
60    pub fn name(&self) -> &'a str {
61        match self {
62            TypeDefinition::Scalar(inner) => inner.name(),
63            TypeDefinition::Object(inner) => inner.name(),
64            TypeDefinition::Interface(inner) => inner.name(),
65            TypeDefinition::Union(inner) => inner.name(),
66            TypeDefinition::Enum(inner) => inner.name(),
67            TypeDefinition::InputObject(inner) => inner.name(),
68        }
69    }
70
71    pub fn directives(&self) -> Iter<'a, Directive<'a>> {
72        match self {
73            TypeDefinition::Scalar(inner) => inner.directives(),
74            TypeDefinition::Object(inner) => inner.directives(),
75            TypeDefinition::Interface(inner) => inner.directives(),
76            TypeDefinition::Union(inner) => inner.directives(),
77            TypeDefinition::Enum(inner) => inner.directives(),
78            TypeDefinition::InputObject(inner) => inner.directives(),
79        }
80    }
81
82    pub fn span(&self) -> crate::Span {
83        match self {
84            TypeDefinition::Scalar(inner) => inner.span(),
85            TypeDefinition::Object(inner) => inner.span(),
86            TypeDefinition::Interface(inner) => inner.span(),
87            TypeDefinition::Union(inner) => inner.span(),
88            TypeDefinition::Enum(inner) => inner.span(),
89            TypeDefinition::InputObject(inner) => inner.span(),
90        }
91    }
92
93    pub fn description(&self) -> Option<Description<'a>> {
94        match self {
95            TypeDefinition::Scalar(inner) => inner.description(),
96            TypeDefinition::Object(inner) => inner.description(),
97            TypeDefinition::Interface(inner) => inner.description(),
98            TypeDefinition::Union(inner) => inner.description(),
99            TypeDefinition::Enum(inner) => inner.description(),
100            TypeDefinition::InputObject(inner) => inner.description(),
101        }
102    }
103}
104
105impl TypeSystemId for DefinitionId {
106    type Reader<'a> = Definition<'a>;
107
108    fn read(self, document: &super::TypeSystemDocument) -> Self::Reader<'_> {
109        match document.lookup(self) {
110            DefinitionRecord::Schema(id) => Definition::Schema(document.read(*id)),
111            DefinitionRecord::Scalar(id) => {
112                Definition::Type(TypeDefinition::Scalar(document.read(*id)))
113            }
114            DefinitionRecord::Object(id) => {
115                Definition::Type(TypeDefinition::Object(document.read(*id)))
116            }
117            DefinitionRecord::Interface(id) => {
118                Definition::Type(TypeDefinition::Interface(document.read(*id)))
119            }
120            DefinitionRecord::Union(id) => {
121                Definition::Type(TypeDefinition::Union(document.read(*id)))
122            }
123            DefinitionRecord::Enum(id) => {
124                Definition::Type(TypeDefinition::Enum(document.read(*id)))
125            }
126            DefinitionRecord::InputObject(id) => {
127                Definition::Type(TypeDefinition::InputObject(document.read(*id)))
128            }
129            DefinitionRecord::SchemaExtension(id) => {
130                Definition::SchemaExtension(document.read(*id))
131            }
132            DefinitionRecord::ScalarExtension(id) => {
133                Definition::TypeExtension(TypeDefinition::Scalar(document.read(*id)))
134            }
135            DefinitionRecord::ObjectExtension(id) => {
136                Definition::TypeExtension(TypeDefinition::Object(document.read(*id)))
137            }
138            DefinitionRecord::InterfaceExtension(id) => {
139                Definition::TypeExtension(TypeDefinition::Interface(document.read(*id)))
140            }
141            DefinitionRecord::UnionExtension(id) => {
142                Definition::TypeExtension(TypeDefinition::Union(document.read(*id)))
143            }
144            DefinitionRecord::EnumExtension(id) => {
145                Definition::TypeExtension(TypeDefinition::Enum(document.read(*id)))
146            }
147            DefinitionRecord::InputObjectExtension(id) => {
148                Definition::TypeExtension(TypeDefinition::InputObject(document.read(*id)))
149            }
150            DefinitionRecord::Directive(id) => Definition::Directive(document.read(*id)),
151        }
152    }
153}
154
155impl IdReader for Definition<'_> {
156    type Id = DefinitionId;
157    type Reader<'a> = Definition<'a>;
158
159    fn new(id: Self::Id, document: &'_ super::TypeSystemDocument) -> Self::Reader<'_> {
160        document.read(id)
161    }
162}
cynic_parser/type_system/definitions.rs

cynic_parser/type_system/
definitions.rs
