diff --git a/.gitignore b/.gitignore index a00499c..b471f20 100644 --- a/.gitignore +++ b/.gitignore @@ -3,9 +3,9 @@ bison.tab.hpp *.o parser.output dump_json_ast -Ast.h -Ast.cpp -AstVisitor.h +/Ast.h +/Ast.cpp +/AstVisitor.h *.dSYM CMakeCache.txt CMakeFiles diff --git a/CMakeLists.txt b/CMakeLists.txt index dd55f05..cd34403 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -7,12 +7,13 @@ INCLUDE(version) SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=gnu++11") -FIND_PACKAGE(PythonInterp 2 REQUIRED) +FIND_PACKAGE(PythonInterp 2) IF (NOT PYTHON_VERSION_MAJOR EQUAL 2) - MESSAGE(FATAL_ERROR "Python 2 is required.") + MESSAGE(WARNING "Python 2 is required.") +ELSE() + FIND_PROGRAM(CTYPESGEN_FOUND ctypesgen.py) ENDIF() -FIND_PROGRAM(CTYPESGEN_FOUND ctypesgen.py) FIND_PACKAGE(BISON 3) FIND_PACKAGE(FLEX) @@ -35,7 +36,7 @@ ELSE() ${CMAKE_CURRENT_SOURCE_DIR}/parsergen/location.hh ${CMAKE_CURRENT_SOURCE_DIR}/parsergen/position.hh ${CMAKE_CURRENT_SOURCE_DIR}/parsergen/stack.hh - ${CMAKE_CURRENT_BINARY_DIR}) + DESTINATION ${CMAKE_CURRENT_BINARY_DIR}) ENDIF() IF(FLEX_FOUND) @@ -48,7 +49,7 @@ ELSE() FILE(COPY ${CMAKE_CURRENT_SOURCE_DIR}/parsergen/lexer.cpp ${CMAKE_CURRENT_SOURCE_DIR}/parsergen/lexer.h - ${CMAKE_CURRENT_BINARY_DIR}) + DESTINATION ${CMAKE_CURRENT_BINARY_DIR}) ENDIF() FILE(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/c) @@ -89,21 +90,29 @@ FUNCTION(GENERATE_AST_FILE FILE_TYPE FILE_RELATIVE_PATH) DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/ast/ast.ast ${CMAKE_CURRENT_SOURCE_DIR}/ast/ast.py ${CMAKE_CURRENT_SOURCE_DIR}/ast/${FILE_TYPE}.py) ENDFUNCTION(GENERATE_AST_FILE) -GENERATE_AST_FILE(cxx Ast.h) - -GENERATE_AST_FILE(cxx_visitor AstVisitor.h) - -GENERATE_AST_FILE(cxx_impl Ast.cpp) - -GENERATE_AST_FILE(c c/GraphQLAst.h) - -GENERATE_AST_FILE(c_impl c/GraphQLAst.cpp) - -GENERATE_AST_FILE(c_visitor_impl c/GraphQLAstForEachConcreteType.h) - -GENERATE_AST_FILE(cxx_json_visitor_header JsonVisitor.h.inc) - -GENERATE_AST_FILE(cxx_json_visitor_impl JsonVisitor.cpp.inc) +IF(PythonInterp_FOUND) + GENERATE_AST_FILE(cxx Ast.h) + GENERATE_AST_FILE(cxx_visitor AstVisitor.h) + GENERATE_AST_FILE(cxx_impl Ast.cpp) + GENERATE_AST_FILE(c c/GraphQLAst.h) + GENERATE_AST_FILE(c_impl c/GraphQLAst.cpp) + GENERATE_AST_FILE(c_visitor_impl c/GraphQLAstForEachConcreteType.h) + GENERATE_AST_FILE(cxx_json_visitor_header JsonVisitor.h.inc) + GENERATE_AST_FILE(cxx_json_visitor_impl JsonVisitor.cpp.inc) +ELSE() + FILE(COPY + ${CMAKE_CURRENT_SOURCE_DIR}/pregenerated_ast/Ast.h + ${CMAKE_CURRENT_SOURCE_DIR}/pregenerated_ast/Ast.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/pregenerated_ast/AstVisitor.h + ${CMAKE_CURRENT_SOURCE_DIR}/pregenerated_ast/JsonVisitor.h.inc + ${CMAKE_CURRENT_SOURCE_DIR}/pregenerated_ast/JsonVisitor.cpp.inc + DESTINATION ${CMAKE_CURRENT_SOURCE_DIR}) + FILE(COPY + ${CMAKE_CURRENT_SOURCE_DIR}/pregenerated_ast/c/GraphQLAst.h + ${CMAKE_CURRENT_SOURCE_DIR}/pregenerated_ast/c/GraphQLAst.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/pregenerated_ast/c/GraphQLAstForEachConcreteType.h + DESTINATION ${CMAKE_CURRENT_SOURCE_DIR}/c) +ENDIF() ADD_SUBDIRECTORY(python) diff --git a/libgraphqlparser.pc.in b/libgraphqlparser.pc.in index c5720e6..7b3ae7a 100644 --- a/libgraphqlparser.pc.in +++ b/libgraphqlparser.pc.in @@ -1,11 +1,11 @@ prefix=@CMAKE_INSTALL_PREFIX@ exec_prefix=${prefix} libdir=${exec_prefix}/lib -includedir=${prefix}/include/graphqlparser +includedir=${prefix}/include/ Name: @CMAKE_PROJECT_NAME@ Description: facebook graphql parsing library Version: @LIBGRAPHQLPARSER_VERSION@ Libs: -L${libdir} -lgraphqlparser Libs.private: -Cflags: -I${includedir} +Cflags: -I${includedir} diff --git a/pregenerated_ast/Ast.cpp b/pregenerated_ast/Ast.cpp new file mode 100644 index 0000000..9d3f662 --- /dev/null +++ b/pregenerated_ast/Ast.cpp @@ -0,0 +1,346 @@ +/** + * Copyright 2019-present GraphQL Foundation + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +/** @generated */ + +#include "Ast.h" +#include "AstVisitor.h" + +namespace facebook { +namespace graphql { +namespace ast { + +void Document::accept(visitor::AstVisitor *visitor) const { + if (visitor->visitDocument(*this)) { + + { for (const auto &x : *definitions_) { x->accept(visitor); } } + } + visitor->endVisitDocument(*this); +} + +void OperationDefinition::accept(visitor::AstVisitor *visitor) const { + if (visitor->visitOperationDefinition(*this)) { + + if (name_) { name_->accept(visitor); } + if (variableDefinitions_) { for (const auto &x : *variableDefinitions_) { x->accept(visitor); } } + if (directives_) { for (const auto &x : *directives_) { x->accept(visitor); } } + selectionSet_->accept(visitor); + } + visitor->endVisitOperationDefinition(*this); +} + +void VariableDefinition::accept(visitor::AstVisitor *visitor) const { + if (visitor->visitVariableDefinition(*this)) { + + variable_->accept(visitor); + type_->accept(visitor); + if (defaultValue_) { defaultValue_->accept(visitor); } + } + visitor->endVisitVariableDefinition(*this); +} + +void SelectionSet::accept(visitor::AstVisitor *visitor) const { + if (visitor->visitSelectionSet(*this)) { + + { for (const auto &x : *selections_) { x->accept(visitor); } } + } + visitor->endVisitSelectionSet(*this); +} + +void Field::accept(visitor::AstVisitor *visitor) const { + if (visitor->visitField(*this)) { + + if (alias_) { alias_->accept(visitor); } + name_->accept(visitor); + if (arguments_) { for (const auto &x : *arguments_) { x->accept(visitor); } } + if (directives_) { for (const auto &x : *directives_) { x->accept(visitor); } } + if (selectionSet_) { selectionSet_->accept(visitor); } + } + visitor->endVisitField(*this); +} + +void Argument::accept(visitor::AstVisitor *visitor) const { + if (visitor->visitArgument(*this)) { + + name_->accept(visitor); + value_->accept(visitor); + } + visitor->endVisitArgument(*this); +} + +void FragmentSpread::accept(visitor::AstVisitor *visitor) const { + if (visitor->visitFragmentSpread(*this)) { + + name_->accept(visitor); + if (directives_) { for (const auto &x : *directives_) { x->accept(visitor); } } + } + visitor->endVisitFragmentSpread(*this); +} + +void InlineFragment::accept(visitor::AstVisitor *visitor) const { + if (visitor->visitInlineFragment(*this)) { + + if (typeCondition_) { typeCondition_->accept(visitor); } + if (directives_) { for (const auto &x : *directives_) { x->accept(visitor); } } + selectionSet_->accept(visitor); + } + visitor->endVisitInlineFragment(*this); +} + +void FragmentDefinition::accept(visitor::AstVisitor *visitor) const { + if (visitor->visitFragmentDefinition(*this)) { + + name_->accept(visitor); + typeCondition_->accept(visitor); + if (directives_) { for (const auto &x : *directives_) { x->accept(visitor); } } + selectionSet_->accept(visitor); + } + visitor->endVisitFragmentDefinition(*this); +} + +void Variable::accept(visitor::AstVisitor *visitor) const { + if (visitor->visitVariable(*this)) { + + name_->accept(visitor); + } + visitor->endVisitVariable(*this); +} + +void IntValue::accept(visitor::AstVisitor *visitor) const { + if (visitor->visitIntValue(*this)) { + + } + visitor->endVisitIntValue(*this); +} + +void FloatValue::accept(visitor::AstVisitor *visitor) const { + if (visitor->visitFloatValue(*this)) { + + } + visitor->endVisitFloatValue(*this); +} + +void StringValue::accept(visitor::AstVisitor *visitor) const { + if (visitor->visitStringValue(*this)) { + + } + visitor->endVisitStringValue(*this); +} + +void BooleanValue::accept(visitor::AstVisitor *visitor) const { + if (visitor->visitBooleanValue(*this)) { + + } + visitor->endVisitBooleanValue(*this); +} + +void NullValue::accept(visitor::AstVisitor *visitor) const { + if (visitor->visitNullValue(*this)) { + + } + visitor->endVisitNullValue(*this); +} + +void EnumValue::accept(visitor::AstVisitor *visitor) const { + if (visitor->visitEnumValue(*this)) { + + } + visitor->endVisitEnumValue(*this); +} + +void ListValue::accept(visitor::AstVisitor *visitor) const { + if (visitor->visitListValue(*this)) { + + { for (const auto &x : *values_) { x->accept(visitor); } } + } + visitor->endVisitListValue(*this); +} + +void ObjectValue::accept(visitor::AstVisitor *visitor) const { + if (visitor->visitObjectValue(*this)) { + + { for (const auto &x : *fields_) { x->accept(visitor); } } + } + visitor->endVisitObjectValue(*this); +} + +void ObjectField::accept(visitor::AstVisitor *visitor) const { + if (visitor->visitObjectField(*this)) { + + name_->accept(visitor); + value_->accept(visitor); + } + visitor->endVisitObjectField(*this); +} + +void Directive::accept(visitor::AstVisitor *visitor) const { + if (visitor->visitDirective(*this)) { + + name_->accept(visitor); + if (arguments_) { for (const auto &x : *arguments_) { x->accept(visitor); } } + } + visitor->endVisitDirective(*this); +} + +void NamedType::accept(visitor::AstVisitor *visitor) const { + if (visitor->visitNamedType(*this)) { + + name_->accept(visitor); + } + visitor->endVisitNamedType(*this); +} + +void ListType::accept(visitor::AstVisitor *visitor) const { + if (visitor->visitListType(*this)) { + + type_->accept(visitor); + } + visitor->endVisitListType(*this); +} + +void NonNullType::accept(visitor::AstVisitor *visitor) const { + if (visitor->visitNonNullType(*this)) { + + type_->accept(visitor); + } + visitor->endVisitNonNullType(*this); +} + +void Name::accept(visitor::AstVisitor *visitor) const { + if (visitor->visitName(*this)) { + + } + visitor->endVisitName(*this); +} + +void SchemaDefinition::accept(visitor::AstVisitor *visitor) const { + if (visitor->visitSchemaDefinition(*this)) { + + if (directives_) { for (const auto &x : *directives_) { x->accept(visitor); } } + { for (const auto &x : *operationTypes_) { x->accept(visitor); } } + } + visitor->endVisitSchemaDefinition(*this); +} + +void OperationTypeDefinition::accept(visitor::AstVisitor *visitor) const { + if (visitor->visitOperationTypeDefinition(*this)) { + + type_->accept(visitor); + } + visitor->endVisitOperationTypeDefinition(*this); +} + +void ScalarTypeDefinition::accept(visitor::AstVisitor *visitor) const { + if (visitor->visitScalarTypeDefinition(*this)) { + + name_->accept(visitor); + if (directives_) { for (const auto &x : *directives_) { x->accept(visitor); } } + } + visitor->endVisitScalarTypeDefinition(*this); +} + +void ObjectTypeDefinition::accept(visitor::AstVisitor *visitor) const { + if (visitor->visitObjectTypeDefinition(*this)) { + + name_->accept(visitor); + if (interfaces_) { for (const auto &x : *interfaces_) { x->accept(visitor); } } + if (directives_) { for (const auto &x : *directives_) { x->accept(visitor); } } + { for (const auto &x : *fields_) { x->accept(visitor); } } + } + visitor->endVisitObjectTypeDefinition(*this); +} + +void FieldDefinition::accept(visitor::AstVisitor *visitor) const { + if (visitor->visitFieldDefinition(*this)) { + + name_->accept(visitor); + if (arguments_) { for (const auto &x : *arguments_) { x->accept(visitor); } } + type_->accept(visitor); + if (directives_) { for (const auto &x : *directives_) { x->accept(visitor); } } + } + visitor->endVisitFieldDefinition(*this); +} + +void InputValueDefinition::accept(visitor::AstVisitor *visitor) const { + if (visitor->visitInputValueDefinition(*this)) { + + name_->accept(visitor); + type_->accept(visitor); + if (defaultValue_) { defaultValue_->accept(visitor); } + if (directives_) { for (const auto &x : *directives_) { x->accept(visitor); } } + } + visitor->endVisitInputValueDefinition(*this); +} + +void InterfaceTypeDefinition::accept(visitor::AstVisitor *visitor) const { + if (visitor->visitInterfaceTypeDefinition(*this)) { + + name_->accept(visitor); + if (directives_) { for (const auto &x : *directives_) { x->accept(visitor); } } + { for (const auto &x : *fields_) { x->accept(visitor); } } + } + visitor->endVisitInterfaceTypeDefinition(*this); +} + +void UnionTypeDefinition::accept(visitor::AstVisitor *visitor) const { + if (visitor->visitUnionTypeDefinition(*this)) { + + name_->accept(visitor); + if (directives_) { for (const auto &x : *directives_) { x->accept(visitor); } } + { for (const auto &x : *types_) { x->accept(visitor); } } + } + visitor->endVisitUnionTypeDefinition(*this); +} + +void EnumTypeDefinition::accept(visitor::AstVisitor *visitor) const { + if (visitor->visitEnumTypeDefinition(*this)) { + + name_->accept(visitor); + if (directives_) { for (const auto &x : *directives_) { x->accept(visitor); } } + { for (const auto &x : *values_) { x->accept(visitor); } } + } + visitor->endVisitEnumTypeDefinition(*this); +} + +void EnumValueDefinition::accept(visitor::AstVisitor *visitor) const { + if (visitor->visitEnumValueDefinition(*this)) { + + name_->accept(visitor); + if (directives_) { for (const auto &x : *directives_) { x->accept(visitor); } } + } + visitor->endVisitEnumValueDefinition(*this); +} + +void InputObjectTypeDefinition::accept(visitor::AstVisitor *visitor) const { + if (visitor->visitInputObjectTypeDefinition(*this)) { + + name_->accept(visitor); + if (directives_) { for (const auto &x : *directives_) { x->accept(visitor); } } + { for (const auto &x : *fields_) { x->accept(visitor); } } + } + visitor->endVisitInputObjectTypeDefinition(*this); +} + +void TypeExtensionDefinition::accept(visitor::AstVisitor *visitor) const { + if (visitor->visitTypeExtensionDefinition(*this)) { + + definition_->accept(visitor); + } + visitor->endVisitTypeExtensionDefinition(*this); +} + +void DirectiveDefinition::accept(visitor::AstVisitor *visitor) const { + if (visitor->visitDirectiveDefinition(*this)) { + + name_->accept(visitor); + if (arguments_) { for (const auto &x : *arguments_) { x->accept(visitor); } } + { for (const auto &x : *locations_) { x->accept(visitor); } } + } + visitor->endVisitDirectiveDefinition(*this); +} + +} // namespace ast +} // namespace graphql +} // namespace facebook diff --git a/pregenerated_ast/Ast.h b/pregenerated_ast/Ast.h new file mode 100644 index 0000000..9104de2 --- /dev/null +++ b/pregenerated_ast/Ast.h @@ -0,0 +1,1214 @@ +/** + * Copyright 2019-present GraphQL Foundation + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +/** @generated */ +#pragma once + +#include "AstNode.h" + +#include +#include +#include +#include + +namespace facebook { +namespace graphql { +namespace ast { + +// The parser uses strdup to move from yytext to the heap, so we need +// to use free instead of delete. +struct CDeleter { + void operator()(const char *p) const { free((void *)p); } +}; + +class Definition; +class Document; +class OperationDefinition; +class VariableDefinition; +class SelectionSet; +class Selection; +class Field; +class Argument; +class FragmentSpread; +class InlineFragment; +class FragmentDefinition; +class Value; +class Variable; +class IntValue; +class FloatValue; +class StringValue; +class BooleanValue; +class NullValue; +class EnumValue; +class ListValue; +class ObjectValue; +class ObjectField; +class Directive; +class Type; +class NamedType; +class ListType; +class NonNullType; +class Name; +class SchemaDefinition; +class OperationTypeDefinition; +class ScalarTypeDefinition; +class ObjectTypeDefinition; +class FieldDefinition; +class InputValueDefinition; +class InterfaceTypeDefinition; +class UnionTypeDefinition; +class EnumTypeDefinition; +class EnumValueDefinition; +class InputObjectTypeDefinition; +class TypeExtensionDefinition; +class DirectiveDefinition; + +class Definition : public Node { + public: + explicit Definition( + const yy::location &location + + ) + : Node(location) + + {} +}; + +class Document : public Node { + std::unique_ptr>> definitions_; + public: + explicit Document( + const yy::location &location, + std::vector> * definitions + ) + : Node(location), + definitions_(definitions) + {} + + ~Document() {} + + Document(const Document&) = delete; + Document& operator=(const Document&) = delete; + + const std::vector>& getDefinitions() const + { return *definitions_; } + + void accept(visitor::AstVisitor *visitor) const override; +}; + + +class OperationDefinition : public Definition { + std::unique_ptr operation_; + std::unique_ptr name_; + std::unique_ptr>> variableDefinitions_; + std::unique_ptr>> directives_; + std::unique_ptr selectionSet_; + public: + explicit OperationDefinition( + const yy::location &location, + const char * operation, + Name * name, + std::vector> * variableDefinitions, + std::vector> * directives, + SelectionSet * selectionSet + ) + : Definition(location), + operation_(operation), + name_(name), + variableDefinitions_(variableDefinitions), + directives_(directives), + selectionSet_(selectionSet) + {} + + ~OperationDefinition() {} + + OperationDefinition(const OperationDefinition&) = delete; + OperationDefinition& operator=(const OperationDefinition&) = delete; + + const char * getOperation() const + { return operation_.get(); } + + const Name* getName() const + { return name_.get(); } + + const std::vector>* getVariableDefinitions() const + { return variableDefinitions_.get(); } + + const std::vector>* getDirectives() const + { return directives_.get(); } + + const SelectionSet& getSelectionSet() const + { return *selectionSet_; } + + void accept(visitor::AstVisitor *visitor) const override; +}; + + +class VariableDefinition : public Node { + std::unique_ptr variable_; + std::unique_ptr type_; + std::unique_ptr defaultValue_; + public: + explicit VariableDefinition( + const yy::location &location, + Variable * variable, + Type * type, + Value * defaultValue + ) + : Node(location), + variable_(variable), + type_(type), + defaultValue_(defaultValue) + {} + + ~VariableDefinition() {} + + VariableDefinition(const VariableDefinition&) = delete; + VariableDefinition& operator=(const VariableDefinition&) = delete; + + const Variable& getVariable() const + { return *variable_; } + + const Type& getType() const + { return *type_; } + + const Value* getDefaultValue() const + { return defaultValue_.get(); } + + void accept(visitor::AstVisitor *visitor) const override; +}; + + +class SelectionSet : public Node { + std::unique_ptr>> selections_; + public: + explicit SelectionSet( + const yy::location &location, + std::vector> * selections + ) + : Node(location), + selections_(selections) + {} + + ~SelectionSet() {} + + SelectionSet(const SelectionSet&) = delete; + SelectionSet& operator=(const SelectionSet&) = delete; + + const std::vector>& getSelections() const + { return *selections_; } + + void accept(visitor::AstVisitor *visitor) const override; +}; + + +class Selection : public Node { + public: + explicit Selection( + const yy::location &location + + ) + : Node(location) + + {} +}; + +class Field : public Selection { + std::unique_ptr alias_; + std::unique_ptr name_; + std::unique_ptr>> arguments_; + std::unique_ptr>> directives_; + std::unique_ptr selectionSet_; + public: + explicit Field( + const yy::location &location, + Name * alias, + Name * name, + std::vector> * arguments, + std::vector> * directives, + SelectionSet * selectionSet + ) + : Selection(location), + alias_(alias), + name_(name), + arguments_(arguments), + directives_(directives), + selectionSet_(selectionSet) + {} + + ~Field() {} + + Field(const Field&) = delete; + Field& operator=(const Field&) = delete; + + const Name* getAlias() const + { return alias_.get(); } + + const Name& getName() const + { return *name_; } + + const std::vector>* getArguments() const + { return arguments_.get(); } + + const std::vector>* getDirectives() const + { return directives_.get(); } + + const SelectionSet* getSelectionSet() const + { return selectionSet_.get(); } + + void accept(visitor::AstVisitor *visitor) const override; +}; + + +class Argument : public Node { + std::unique_ptr name_; + std::unique_ptr value_; + public: + explicit Argument( + const yy::location &location, + Name * name, + Value * value + ) + : Node(location), + name_(name), + value_(value) + {} + + ~Argument() {} + + Argument(const Argument&) = delete; + Argument& operator=(const Argument&) = delete; + + const Name& getName() const + { return *name_; } + + const Value& getValue() const + { return *value_; } + + void accept(visitor::AstVisitor *visitor) const override; +}; + + +class FragmentSpread : public Selection { + std::unique_ptr name_; + std::unique_ptr>> directives_; + public: + explicit FragmentSpread( + const yy::location &location, + Name * name, + std::vector> * directives + ) + : Selection(location), + name_(name), + directives_(directives) + {} + + ~FragmentSpread() {} + + FragmentSpread(const FragmentSpread&) = delete; + FragmentSpread& operator=(const FragmentSpread&) = delete; + + const Name& getName() const + { return *name_; } + + const std::vector>* getDirectives() const + { return directives_.get(); } + + void accept(visitor::AstVisitor *visitor) const override; +}; + + +class InlineFragment : public Selection { + std::unique_ptr typeCondition_; + std::unique_ptr>> directives_; + std::unique_ptr selectionSet_; + public: + explicit InlineFragment( + const yy::location &location, + NamedType * typeCondition, + std::vector> * directives, + SelectionSet * selectionSet + ) + : Selection(location), + typeCondition_(typeCondition), + directives_(directives), + selectionSet_(selectionSet) + {} + + ~InlineFragment() {} + + InlineFragment(const InlineFragment&) = delete; + InlineFragment& operator=(const InlineFragment&) = delete; + + const NamedType* getTypeCondition() const + { return typeCondition_.get(); } + + const std::vector>* getDirectives() const + { return directives_.get(); } + + const SelectionSet& getSelectionSet() const + { return *selectionSet_; } + + void accept(visitor::AstVisitor *visitor) const override; +}; + + +class FragmentDefinition : public Definition { + std::unique_ptr name_; + std::unique_ptr typeCondition_; + std::unique_ptr>> directives_; + std::unique_ptr selectionSet_; + public: + explicit FragmentDefinition( + const yy::location &location, + Name * name, + NamedType * typeCondition, + std::vector> * directives, + SelectionSet * selectionSet + ) + : Definition(location), + name_(name), + typeCondition_(typeCondition), + directives_(directives), + selectionSet_(selectionSet) + {} + + ~FragmentDefinition() {} + + FragmentDefinition(const FragmentDefinition&) = delete; + FragmentDefinition& operator=(const FragmentDefinition&) = delete; + + const Name& getName() const + { return *name_; } + + const NamedType& getTypeCondition() const + { return *typeCondition_; } + + const std::vector>* getDirectives() const + { return directives_.get(); } + + const SelectionSet& getSelectionSet() const + { return *selectionSet_; } + + void accept(visitor::AstVisitor *visitor) const override; +}; + + +class Value : public Node { + public: + explicit Value( + const yy::location &location + + ) + : Node(location) + + {} +}; + +class Variable : public Value { + std::unique_ptr name_; + public: + explicit Variable( + const yy::location &location, + Name * name + ) + : Value(location), + name_(name) + {} + + ~Variable() {} + + Variable(const Variable&) = delete; + Variable& operator=(const Variable&) = delete; + + const Name& getName() const + { return *name_; } + + void accept(visitor::AstVisitor *visitor) const override; +}; + + +class IntValue : public Value { + std::unique_ptr value_; + public: + explicit IntValue( + const yy::location &location, + const char * value + ) + : Value(location), + value_(value) + {} + + ~IntValue() {} + + IntValue(const IntValue&) = delete; + IntValue& operator=(const IntValue&) = delete; + + const char * getValue() const + { return value_.get(); } + + void accept(visitor::AstVisitor *visitor) const override; +}; + + +class FloatValue : public Value { + std::unique_ptr value_; + public: + explicit FloatValue( + const yy::location &location, + const char * value + ) + : Value(location), + value_(value) + {} + + ~FloatValue() {} + + FloatValue(const FloatValue&) = delete; + FloatValue& operator=(const FloatValue&) = delete; + + const char * getValue() const + { return value_.get(); } + + void accept(visitor::AstVisitor *visitor) const override; +}; + + +class StringValue : public Value { + std::unique_ptr value_; + public: + explicit StringValue( + const yy::location &location, + const char * value + ) + : Value(location), + value_(value) + {} + + ~StringValue() {} + + StringValue(const StringValue&) = delete; + StringValue& operator=(const StringValue&) = delete; + + const char * getValue() const + { return value_.get(); } + + void accept(visitor::AstVisitor *visitor) const override; +}; + + +class BooleanValue : public Value { + bool value_; + public: + explicit BooleanValue( + const yy::location &location, + bool value + ) + : Value(location), + value_(value) + {} + + ~BooleanValue() {} + + BooleanValue(const BooleanValue&) = delete; + BooleanValue& operator=(const BooleanValue&) = delete; + + bool getValue() const + { return value_; } + + void accept(visitor::AstVisitor *visitor) const override; +}; + + +class NullValue : public Value { + public: + explicit NullValue( + const yy::location &location + + ) + : Value(location) + + {} + + ~NullValue() {} + + NullValue(const NullValue&) = delete; + NullValue& operator=(const NullValue&) = delete; + + void accept(visitor::AstVisitor *visitor) const override; +}; + + +class EnumValue : public Value { + std::unique_ptr value_; + public: + explicit EnumValue( + const yy::location &location, + const char * value + ) + : Value(location), + value_(value) + {} + + ~EnumValue() {} + + EnumValue(const EnumValue&) = delete; + EnumValue& operator=(const EnumValue&) = delete; + + const char * getValue() const + { return value_.get(); } + + void accept(visitor::AstVisitor *visitor) const override; +}; + + +class ListValue : public Value { + std::unique_ptr>> values_; + public: + explicit ListValue( + const yy::location &location, + std::vector> * values + ) + : Value(location), + values_(values) + {} + + ~ListValue() {} + + ListValue(const ListValue&) = delete; + ListValue& operator=(const ListValue&) = delete; + + const std::vector>& getValues() const + { return *values_; } + + void accept(visitor::AstVisitor *visitor) const override; +}; + + +class ObjectValue : public Value { + std::unique_ptr>> fields_; + public: + explicit ObjectValue( + const yy::location &location, + std::vector> * fields + ) + : Value(location), + fields_(fields) + {} + + ~ObjectValue() {} + + ObjectValue(const ObjectValue&) = delete; + ObjectValue& operator=(const ObjectValue&) = delete; + + const std::vector>& getFields() const + { return *fields_; } + + void accept(visitor::AstVisitor *visitor) const override; +}; + + +class ObjectField : public Node { + std::unique_ptr name_; + std::unique_ptr value_; + public: + explicit ObjectField( + const yy::location &location, + Name * name, + Value * value + ) + : Node(location), + name_(name), + value_(value) + {} + + ~ObjectField() {} + + ObjectField(const ObjectField&) = delete; + ObjectField& operator=(const ObjectField&) = delete; + + const Name& getName() const + { return *name_; } + + const Value& getValue() const + { return *value_; } + + void accept(visitor::AstVisitor *visitor) const override; +}; + + +class Directive : public Node { + std::unique_ptr name_; + std::unique_ptr>> arguments_; + public: + explicit Directive( + const yy::location &location, + Name * name, + std::vector> * arguments + ) + : Node(location), + name_(name), + arguments_(arguments) + {} + + ~Directive() {} + + Directive(const Directive&) = delete; + Directive& operator=(const Directive&) = delete; + + const Name& getName() const + { return *name_; } + + const std::vector>* getArguments() const + { return arguments_.get(); } + + void accept(visitor::AstVisitor *visitor) const override; +}; + + +class Type : public Node { + public: + explicit Type( + const yy::location &location + + ) + : Node(location) + + {} +}; + +class NamedType : public Type { + std::unique_ptr name_; + public: + explicit NamedType( + const yy::location &location, + Name * name + ) + : Type(location), + name_(name) + {} + + ~NamedType() {} + + NamedType(const NamedType&) = delete; + NamedType& operator=(const NamedType&) = delete; + + const Name& getName() const + { return *name_; } + + void accept(visitor::AstVisitor *visitor) const override; +}; + + +class ListType : public Type { + std::unique_ptr type_; + public: + explicit ListType( + const yy::location &location, + Type * type + ) + : Type(location), + type_(type) + {} + + ~ListType() {} + + ListType(const ListType&) = delete; + ListType& operator=(const ListType&) = delete; + + const Type& getType() const + { return *type_; } + + void accept(visitor::AstVisitor *visitor) const override; +}; + + +class NonNullType : public Type { + std::unique_ptr type_; + public: + explicit NonNullType( + const yy::location &location, + Type * type + ) + : Type(location), + type_(type) + {} + + ~NonNullType() {} + + NonNullType(const NonNullType&) = delete; + NonNullType& operator=(const NonNullType&) = delete; + + const Type& getType() const + { return *type_; } + + void accept(visitor::AstVisitor *visitor) const override; +}; + + +class Name : public Node { + std::unique_ptr value_; + public: + explicit Name( + const yy::location &location, + const char * value + ) + : Node(location), + value_(value) + {} + + ~Name() {} + + Name(const Name&) = delete; + Name& operator=(const Name&) = delete; + + const char * getValue() const + { return value_.get(); } + + void accept(visitor::AstVisitor *visitor) const override; +}; + + +class SchemaDefinition : public Definition { + std::unique_ptr>> directives_; + std::unique_ptr>> operationTypes_; + public: + explicit SchemaDefinition( + const yy::location &location, + std::vector> * directives, + std::vector> * operationTypes + ) + : Definition(location), + directives_(directives), + operationTypes_(operationTypes) + {} + + ~SchemaDefinition() {} + + SchemaDefinition(const SchemaDefinition&) = delete; + SchemaDefinition& operator=(const SchemaDefinition&) = delete; + + const std::vector>* getDirectives() const + { return directives_.get(); } + + const std::vector>& getOperationTypes() const + { return *operationTypes_; } + + void accept(visitor::AstVisitor *visitor) const override; +}; + + +class OperationTypeDefinition : public Node { + std::unique_ptr operation_; + std::unique_ptr type_; + public: + explicit OperationTypeDefinition( + const yy::location &location, + const char * operation, + NamedType * type + ) + : Node(location), + operation_(operation), + type_(type) + {} + + ~OperationTypeDefinition() {} + + OperationTypeDefinition(const OperationTypeDefinition&) = delete; + OperationTypeDefinition& operator=(const OperationTypeDefinition&) = delete; + + const char * getOperation() const + { return operation_.get(); } + + const NamedType& getType() const + { return *type_; } + + void accept(visitor::AstVisitor *visitor) const override; +}; + + +class ScalarTypeDefinition : public Definition { + std::unique_ptr name_; + std::unique_ptr>> directives_; + public: + explicit ScalarTypeDefinition( + const yy::location &location, + Name * name, + std::vector> * directives + ) + : Definition(location), + name_(name), + directives_(directives) + {} + + ~ScalarTypeDefinition() {} + + ScalarTypeDefinition(const ScalarTypeDefinition&) = delete; + ScalarTypeDefinition& operator=(const ScalarTypeDefinition&) = delete; + + const Name& getName() const + { return *name_; } + + const std::vector>* getDirectives() const + { return directives_.get(); } + + void accept(visitor::AstVisitor *visitor) const override; +}; + + +class ObjectTypeDefinition : public Definition { + std::unique_ptr name_; + std::unique_ptr>> interfaces_; + std::unique_ptr>> directives_; + std::unique_ptr>> fields_; + public: + explicit ObjectTypeDefinition( + const yy::location &location, + Name * name, + std::vector> * interfaces, + std::vector> * directives, + std::vector> * fields + ) + : Definition(location), + name_(name), + interfaces_(interfaces), + directives_(directives), + fields_(fields) + {} + + ~ObjectTypeDefinition() {} + + ObjectTypeDefinition(const ObjectTypeDefinition&) = delete; + ObjectTypeDefinition& operator=(const ObjectTypeDefinition&) = delete; + + const Name& getName() const + { return *name_; } + + const std::vector>* getInterfaces() const + { return interfaces_.get(); } + + const std::vector>* getDirectives() const + { return directives_.get(); } + + const std::vector>& getFields() const + { return *fields_; } + + void accept(visitor::AstVisitor *visitor) const override; +}; + + +class FieldDefinition : public Node { + std::unique_ptr name_; + std::unique_ptr>> arguments_; + std::unique_ptr type_; + std::unique_ptr>> directives_; + public: + explicit FieldDefinition( + const yy::location &location, + Name * name, + std::vector> * arguments, + Type * type, + std::vector> * directives + ) + : Node(location), + name_(name), + arguments_(arguments), + type_(type), + directives_(directives) + {} + + ~FieldDefinition() {} + + FieldDefinition(const FieldDefinition&) = delete; + FieldDefinition& operator=(const FieldDefinition&) = delete; + + const Name& getName() const + { return *name_; } + + const std::vector>* getArguments() const + { return arguments_.get(); } + + const Type& getType() const + { return *type_; } + + const std::vector>* getDirectives() const + { return directives_.get(); } + + void accept(visitor::AstVisitor *visitor) const override; +}; + + +class InputValueDefinition : public Node { + std::unique_ptr name_; + std::unique_ptr type_; + std::unique_ptr defaultValue_; + std::unique_ptr>> directives_; + public: + explicit InputValueDefinition( + const yy::location &location, + Name * name, + Type * type, + Value * defaultValue, + std::vector> * directives + ) + : Node(location), + name_(name), + type_(type), + defaultValue_(defaultValue), + directives_(directives) + {} + + ~InputValueDefinition() {} + + InputValueDefinition(const InputValueDefinition&) = delete; + InputValueDefinition& operator=(const InputValueDefinition&) = delete; + + const Name& getName() const + { return *name_; } + + const Type& getType() const + { return *type_; } + + const Value* getDefaultValue() const + { return defaultValue_.get(); } + + const std::vector>* getDirectives() const + { return directives_.get(); } + + void accept(visitor::AstVisitor *visitor) const override; +}; + + +class InterfaceTypeDefinition : public Definition { + std::unique_ptr name_; + std::unique_ptr>> directives_; + std::unique_ptr>> fields_; + public: + explicit InterfaceTypeDefinition( + const yy::location &location, + Name * name, + std::vector> * directives, + std::vector> * fields + ) + : Definition(location), + name_(name), + directives_(directives), + fields_(fields) + {} + + ~InterfaceTypeDefinition() {} + + InterfaceTypeDefinition(const InterfaceTypeDefinition&) = delete; + InterfaceTypeDefinition& operator=(const InterfaceTypeDefinition&) = delete; + + const Name& getName() const + { return *name_; } + + const std::vector>* getDirectives() const + { return directives_.get(); } + + const std::vector>& getFields() const + { return *fields_; } + + void accept(visitor::AstVisitor *visitor) const override; +}; + + +class UnionTypeDefinition : public Definition { + std::unique_ptr name_; + std::unique_ptr>> directives_; + std::unique_ptr>> types_; + public: + explicit UnionTypeDefinition( + const yy::location &location, + Name * name, + std::vector> * directives, + std::vector> * types + ) + : Definition(location), + name_(name), + directives_(directives), + types_(types) + {} + + ~UnionTypeDefinition() {} + + UnionTypeDefinition(const UnionTypeDefinition&) = delete; + UnionTypeDefinition& operator=(const UnionTypeDefinition&) = delete; + + const Name& getName() const + { return *name_; } + + const std::vector>* getDirectives() const + { return directives_.get(); } + + const std::vector>& getTypes() const + { return *types_; } + + void accept(visitor::AstVisitor *visitor) const override; +}; + + +class EnumTypeDefinition : public Definition { + std::unique_ptr name_; + std::unique_ptr>> directives_; + std::unique_ptr>> values_; + public: + explicit EnumTypeDefinition( + const yy::location &location, + Name * name, + std::vector> * directives, + std::vector> * values + ) + : Definition(location), + name_(name), + directives_(directives), + values_(values) + {} + + ~EnumTypeDefinition() {} + + EnumTypeDefinition(const EnumTypeDefinition&) = delete; + EnumTypeDefinition& operator=(const EnumTypeDefinition&) = delete; + + const Name& getName() const + { return *name_; } + + const std::vector>* getDirectives() const + { return directives_.get(); } + + const std::vector>& getValues() const + { return *values_; } + + void accept(visitor::AstVisitor *visitor) const override; +}; + + +class EnumValueDefinition : public Node { + std::unique_ptr name_; + std::unique_ptr>> directives_; + public: + explicit EnumValueDefinition( + const yy::location &location, + Name * name, + std::vector> * directives + ) + : Node(location), + name_(name), + directives_(directives) + {} + + ~EnumValueDefinition() {} + + EnumValueDefinition(const EnumValueDefinition&) = delete; + EnumValueDefinition& operator=(const EnumValueDefinition&) = delete; + + const Name& getName() const + { return *name_; } + + const std::vector>* getDirectives() const + { return directives_.get(); } + + void accept(visitor::AstVisitor *visitor) const override; +}; + + +class InputObjectTypeDefinition : public Definition { + std::unique_ptr name_; + std::unique_ptr>> directives_; + std::unique_ptr>> fields_; + public: + explicit InputObjectTypeDefinition( + const yy::location &location, + Name * name, + std::vector> * directives, + std::vector> * fields + ) + : Definition(location), + name_(name), + directives_(directives), + fields_(fields) + {} + + ~InputObjectTypeDefinition() {} + + InputObjectTypeDefinition(const InputObjectTypeDefinition&) = delete; + InputObjectTypeDefinition& operator=(const InputObjectTypeDefinition&) = delete; + + const Name& getName() const + { return *name_; } + + const std::vector>* getDirectives() const + { return directives_.get(); } + + const std::vector>& getFields() const + { return *fields_; } + + void accept(visitor::AstVisitor *visitor) const override; +}; + + +class TypeExtensionDefinition : public Definition { + std::unique_ptr definition_; + public: + explicit TypeExtensionDefinition( + const yy::location &location, + ObjectTypeDefinition * definition + ) + : Definition(location), + definition_(definition) + {} + + ~TypeExtensionDefinition() {} + + TypeExtensionDefinition(const TypeExtensionDefinition&) = delete; + TypeExtensionDefinition& operator=(const TypeExtensionDefinition&) = delete; + + const ObjectTypeDefinition& getDefinition() const + { return *definition_; } + + void accept(visitor::AstVisitor *visitor) const override; +}; + + +class DirectiveDefinition : public Definition { + std::unique_ptr name_; + std::unique_ptr>> arguments_; + std::unique_ptr>> locations_; + public: + explicit DirectiveDefinition( + const yy::location &location, + Name * name, + std::vector> * arguments, + std::vector> * locations + ) + : Definition(location), + name_(name), + arguments_(arguments), + locations_(locations) + {} + + ~DirectiveDefinition() {} + + DirectiveDefinition(const DirectiveDefinition&) = delete; + DirectiveDefinition& operator=(const DirectiveDefinition&) = delete; + + const Name& getName() const + { return *name_; } + + const std::vector>* getArguments() const + { return arguments_.get(); } + + const std::vector>& getLocations() const + { return *locations_; } + + void accept(visitor::AstVisitor *visitor) const override; +}; + + + +} +} +} diff --git a/pregenerated_ast/AstVisitor.h b/pregenerated_ast/AstVisitor.h new file mode 100644 index 0000000..cbaa5aa --- /dev/null +++ b/pregenerated_ast/AstVisitor.h @@ -0,0 +1,137 @@ +/** + * Copyright 2019-present GraphQL Foundation + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +/** @generated */ + +#pragma once + +#include "Ast.h" + +namespace facebook { +namespace graphql { +namespace ast { +namespace visitor { + +class AstVisitor { +public: + virtual ~AstVisitor() {} + + virtual bool visitDocument(const Document &document) { return true; } + virtual void endVisitDocument(const Document &document) { } + + virtual bool visitOperationDefinition(const OperationDefinition &operationDefinition) { return true; } + virtual void endVisitOperationDefinition(const OperationDefinition &operationDefinition) { } + + virtual bool visitVariableDefinition(const VariableDefinition &variableDefinition) { return true; } + virtual void endVisitVariableDefinition(const VariableDefinition &variableDefinition) { } + + virtual bool visitSelectionSet(const SelectionSet &selectionSet) { return true; } + virtual void endVisitSelectionSet(const SelectionSet &selectionSet) { } + + virtual bool visitField(const Field &field) { return true; } + virtual void endVisitField(const Field &field) { } + + virtual bool visitArgument(const Argument &argument) { return true; } + virtual void endVisitArgument(const Argument &argument) { } + + virtual bool visitFragmentSpread(const FragmentSpread &fragmentSpread) { return true; } + virtual void endVisitFragmentSpread(const FragmentSpread &fragmentSpread) { } + + virtual bool visitInlineFragment(const InlineFragment &inlineFragment) { return true; } + virtual void endVisitInlineFragment(const InlineFragment &inlineFragment) { } + + virtual bool visitFragmentDefinition(const FragmentDefinition &fragmentDefinition) { return true; } + virtual void endVisitFragmentDefinition(const FragmentDefinition &fragmentDefinition) { } + + virtual bool visitVariable(const Variable &variable) { return true; } + virtual void endVisitVariable(const Variable &variable) { } + + virtual bool visitIntValue(const IntValue &intValue) { return true; } + virtual void endVisitIntValue(const IntValue &intValue) { } + + virtual bool visitFloatValue(const FloatValue &floatValue) { return true; } + virtual void endVisitFloatValue(const FloatValue &floatValue) { } + + virtual bool visitStringValue(const StringValue &stringValue) { return true; } + virtual void endVisitStringValue(const StringValue &stringValue) { } + + virtual bool visitBooleanValue(const BooleanValue &booleanValue) { return true; } + virtual void endVisitBooleanValue(const BooleanValue &booleanValue) { } + + virtual bool visitNullValue(const NullValue &nullValue) { return true; } + virtual void endVisitNullValue(const NullValue &nullValue) { } + + virtual bool visitEnumValue(const EnumValue &enumValue) { return true; } + virtual void endVisitEnumValue(const EnumValue &enumValue) { } + + virtual bool visitListValue(const ListValue &listValue) { return true; } + virtual void endVisitListValue(const ListValue &listValue) { } + + virtual bool visitObjectValue(const ObjectValue &objectValue) { return true; } + virtual void endVisitObjectValue(const ObjectValue &objectValue) { } + + virtual bool visitObjectField(const ObjectField &objectField) { return true; } + virtual void endVisitObjectField(const ObjectField &objectField) { } + + virtual bool visitDirective(const Directive &directive) { return true; } + virtual void endVisitDirective(const Directive &directive) { } + + virtual bool visitNamedType(const NamedType &namedType) { return true; } + virtual void endVisitNamedType(const NamedType &namedType) { } + + virtual bool visitListType(const ListType &listType) { return true; } + virtual void endVisitListType(const ListType &listType) { } + + virtual bool visitNonNullType(const NonNullType &nonNullType) { return true; } + virtual void endVisitNonNullType(const NonNullType &nonNullType) { } + + virtual bool visitName(const Name &name) { return true; } + virtual void endVisitName(const Name &name) { } + + virtual bool visitSchemaDefinition(const SchemaDefinition &schemaDefinition) { return true; } + virtual void endVisitSchemaDefinition(const SchemaDefinition &schemaDefinition) { } + + virtual bool visitOperationTypeDefinition(const OperationTypeDefinition &operationTypeDefinition) { return true; } + virtual void endVisitOperationTypeDefinition(const OperationTypeDefinition &operationTypeDefinition) { } + + virtual bool visitScalarTypeDefinition(const ScalarTypeDefinition &scalarTypeDefinition) { return true; } + virtual void endVisitScalarTypeDefinition(const ScalarTypeDefinition &scalarTypeDefinition) { } + + virtual bool visitObjectTypeDefinition(const ObjectTypeDefinition &objectTypeDefinition) { return true; } + virtual void endVisitObjectTypeDefinition(const ObjectTypeDefinition &objectTypeDefinition) { } + + virtual bool visitFieldDefinition(const FieldDefinition &fieldDefinition) { return true; } + virtual void endVisitFieldDefinition(const FieldDefinition &fieldDefinition) { } + + virtual bool visitInputValueDefinition(const InputValueDefinition &inputValueDefinition) { return true; } + virtual void endVisitInputValueDefinition(const InputValueDefinition &inputValueDefinition) { } + + virtual bool visitInterfaceTypeDefinition(const InterfaceTypeDefinition &interfaceTypeDefinition) { return true; } + virtual void endVisitInterfaceTypeDefinition(const InterfaceTypeDefinition &interfaceTypeDefinition) { } + + virtual bool visitUnionTypeDefinition(const UnionTypeDefinition &unionTypeDefinition) { return true; } + virtual void endVisitUnionTypeDefinition(const UnionTypeDefinition &unionTypeDefinition) { } + + virtual bool visitEnumTypeDefinition(const EnumTypeDefinition &enumTypeDefinition) { return true; } + virtual void endVisitEnumTypeDefinition(const EnumTypeDefinition &enumTypeDefinition) { } + + virtual bool visitEnumValueDefinition(const EnumValueDefinition &enumValueDefinition) { return true; } + virtual void endVisitEnumValueDefinition(const EnumValueDefinition &enumValueDefinition) { } + + virtual bool visitInputObjectTypeDefinition(const InputObjectTypeDefinition &inputObjectTypeDefinition) { return true; } + virtual void endVisitInputObjectTypeDefinition(const InputObjectTypeDefinition &inputObjectTypeDefinition) { } + + virtual bool visitTypeExtensionDefinition(const TypeExtensionDefinition &typeExtensionDefinition) { return true; } + virtual void endVisitTypeExtensionDefinition(const TypeExtensionDefinition &typeExtensionDefinition) { } + + virtual bool visitDirectiveDefinition(const DirectiveDefinition &directiveDefinition) { return true; } + virtual void endVisitDirectiveDefinition(const DirectiveDefinition &directiveDefinition) { } + +}; + +} +} +} +} diff --git a/pregenerated_ast/JsonVisitor.cpp.inc b/pregenerated_ast/JsonVisitor.cpp.inc new file mode 100644 index 0000000..ff64ba7 --- /dev/null +++ b/pregenerated_ast/JsonVisitor.cpp.inc @@ -0,0 +1,456 @@ +/** + * Copyright 2019-present GraphQL Foundation + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +/** @generated */ +bool JsonVisitor::visitDocument(const Document &node) { + visitNode(); + return true; +} + +void JsonVisitor::endVisitDocument(const Document &node) { + NodeFieldPrinter fields(*this, "Document", node); + fields.printPluralField("definitions", node.getDefinitions()); + + endVisitNode(fields.finishPrinting()); +} + +bool JsonVisitor::visitOperationDefinition(const OperationDefinition &node) { + visitNode(); + return true; +} + +void JsonVisitor::endVisitOperationDefinition(const OperationDefinition &node) { + NodeFieldPrinter fields(*this, "OperationDefinition", node); + fields.printSingularPrimitiveField("operation", node.getOperation()); + fields.printNullableSingularObjectField("name", node.getName()); + fields.printNullablePluralField("variableDefinitions", node.getVariableDefinitions()); + fields.printNullablePluralField("directives", node.getDirectives()); + fields.printSingularObjectField("selectionSet"); + + endVisitNode(fields.finishPrinting()); +} + +bool JsonVisitor::visitVariableDefinition(const VariableDefinition &node) { + visitNode(); + return true; +} + +void JsonVisitor::endVisitVariableDefinition(const VariableDefinition &node) { + NodeFieldPrinter fields(*this, "VariableDefinition", node); + fields.printSingularObjectField("variable"); + fields.printSingularObjectField("type"); + fields.printNullableSingularObjectField("defaultValue", node.getDefaultValue()); + + endVisitNode(fields.finishPrinting()); +} + +bool JsonVisitor::visitSelectionSet(const SelectionSet &node) { + visitNode(); + return true; +} + +void JsonVisitor::endVisitSelectionSet(const SelectionSet &node) { + NodeFieldPrinter fields(*this, "SelectionSet", node); + fields.printPluralField("selections", node.getSelections()); + + endVisitNode(fields.finishPrinting()); +} + +bool JsonVisitor::visitField(const Field &node) { + visitNode(); + return true; +} + +void JsonVisitor::endVisitField(const Field &node) { + NodeFieldPrinter fields(*this, "Field", node); + fields.printNullableSingularObjectField("alias", node.getAlias()); + fields.printSingularObjectField("name"); + fields.printNullablePluralField("arguments", node.getArguments()); + fields.printNullablePluralField("directives", node.getDirectives()); + fields.printNullableSingularObjectField("selectionSet", node.getSelectionSet()); + + endVisitNode(fields.finishPrinting()); +} + +bool JsonVisitor::visitArgument(const Argument &node) { + visitNode(); + return true; +} + +void JsonVisitor::endVisitArgument(const Argument &node) { + NodeFieldPrinter fields(*this, "Argument", node); + fields.printSingularObjectField("name"); + fields.printSingularObjectField("value"); + + endVisitNode(fields.finishPrinting()); +} + +bool JsonVisitor::visitFragmentSpread(const FragmentSpread &node) { + visitNode(); + return true; +} + +void JsonVisitor::endVisitFragmentSpread(const FragmentSpread &node) { + NodeFieldPrinter fields(*this, "FragmentSpread", node); + fields.printSingularObjectField("name"); + fields.printNullablePluralField("directives", node.getDirectives()); + + endVisitNode(fields.finishPrinting()); +} + +bool JsonVisitor::visitInlineFragment(const InlineFragment &node) { + visitNode(); + return true; +} + +void JsonVisitor::endVisitInlineFragment(const InlineFragment &node) { + NodeFieldPrinter fields(*this, "InlineFragment", node); + fields.printNullableSingularObjectField("typeCondition", node.getTypeCondition()); + fields.printNullablePluralField("directives", node.getDirectives()); + fields.printSingularObjectField("selectionSet"); + + endVisitNode(fields.finishPrinting()); +} + +bool JsonVisitor::visitFragmentDefinition(const FragmentDefinition &node) { + visitNode(); + return true; +} + +void JsonVisitor::endVisitFragmentDefinition(const FragmentDefinition &node) { + NodeFieldPrinter fields(*this, "FragmentDefinition", node); + fields.printSingularObjectField("name"); + fields.printSingularObjectField("typeCondition"); + fields.printNullablePluralField("directives", node.getDirectives()); + fields.printSingularObjectField("selectionSet"); + + endVisitNode(fields.finishPrinting()); +} + +bool JsonVisitor::visitVariable(const Variable &node) { + visitNode(); + return true; +} + +void JsonVisitor::endVisitVariable(const Variable &node) { + NodeFieldPrinter fields(*this, "Variable", node); + fields.printSingularObjectField("name"); + + endVisitNode(fields.finishPrinting()); +} + +void JsonVisitor::endVisitIntValue(const IntValue &node) { + NodeFieldPrinter fields(*this, "IntValue", node); + fields.printSingularPrimitiveField("value", node.getValue()); + + printed_.back().emplace_back(fields.finishPrinting()); +} + +void JsonVisitor::endVisitFloatValue(const FloatValue &node) { + NodeFieldPrinter fields(*this, "FloatValue", node); + fields.printSingularPrimitiveField("value", node.getValue()); + + printed_.back().emplace_back(fields.finishPrinting()); +} + +void JsonVisitor::endVisitStringValue(const StringValue &node) { + NodeFieldPrinter fields(*this, "StringValue", node); + fields.printSingularPrimitiveField("value", node.getValue()); + + printed_.back().emplace_back(fields.finishPrinting()); +} + +void JsonVisitor::endVisitBooleanValue(const BooleanValue &node) { + NodeFieldPrinter fields(*this, "BooleanValue", node); + fields.printSingularBooleanField("value", node.getValue()); + + printed_.back().emplace_back(fields.finishPrinting()); +} + +void JsonVisitor::endVisitNullValue(const NullValue &node) { + NodeFieldPrinter fields(*this, "NullValue", node); + + printed_.back().emplace_back(fields.finishPrinting()); +} + +void JsonVisitor::endVisitEnumValue(const EnumValue &node) { + NodeFieldPrinter fields(*this, "EnumValue", node); + fields.printSingularPrimitiveField("value", node.getValue()); + + printed_.back().emplace_back(fields.finishPrinting()); +} + +bool JsonVisitor::visitListValue(const ListValue &node) { + visitNode(); + return true; +} + +void JsonVisitor::endVisitListValue(const ListValue &node) { + NodeFieldPrinter fields(*this, "ListValue", node); + fields.printPluralField("values", node.getValues()); + + endVisitNode(fields.finishPrinting()); +} + +bool JsonVisitor::visitObjectValue(const ObjectValue &node) { + visitNode(); + return true; +} + +void JsonVisitor::endVisitObjectValue(const ObjectValue &node) { + NodeFieldPrinter fields(*this, "ObjectValue", node); + fields.printPluralField("fields", node.getFields()); + + endVisitNode(fields.finishPrinting()); +} + +bool JsonVisitor::visitObjectField(const ObjectField &node) { + visitNode(); + return true; +} + +void JsonVisitor::endVisitObjectField(const ObjectField &node) { + NodeFieldPrinter fields(*this, "ObjectField", node); + fields.printSingularObjectField("name"); + fields.printSingularObjectField("value"); + + endVisitNode(fields.finishPrinting()); +} + +bool JsonVisitor::visitDirective(const Directive &node) { + visitNode(); + return true; +} + +void JsonVisitor::endVisitDirective(const Directive &node) { + NodeFieldPrinter fields(*this, "Directive", node); + fields.printSingularObjectField("name"); + fields.printNullablePluralField("arguments", node.getArguments()); + + endVisitNode(fields.finishPrinting()); +} + +bool JsonVisitor::visitNamedType(const NamedType &node) { + visitNode(); + return true; +} + +void JsonVisitor::endVisitNamedType(const NamedType &node) { + NodeFieldPrinter fields(*this, "NamedType", node); + fields.printSingularObjectField("name"); + + endVisitNode(fields.finishPrinting()); +} + +bool JsonVisitor::visitListType(const ListType &node) { + visitNode(); + return true; +} + +void JsonVisitor::endVisitListType(const ListType &node) { + NodeFieldPrinter fields(*this, "ListType", node); + fields.printSingularObjectField("type"); + + endVisitNode(fields.finishPrinting()); +} + +bool JsonVisitor::visitNonNullType(const NonNullType &node) { + visitNode(); + return true; +} + +void JsonVisitor::endVisitNonNullType(const NonNullType &node) { + NodeFieldPrinter fields(*this, "NonNullType", node); + fields.printSingularObjectField("type"); + + endVisitNode(fields.finishPrinting()); +} + +void JsonVisitor::endVisitName(const Name &node) { + NodeFieldPrinter fields(*this, "Name", node); + fields.printSingularPrimitiveField("value", node.getValue()); + + printed_.back().emplace_back(fields.finishPrinting()); +} + +bool JsonVisitor::visitSchemaDefinition(const SchemaDefinition &node) { + visitNode(); + return true; +} + +void JsonVisitor::endVisitSchemaDefinition(const SchemaDefinition &node) { + NodeFieldPrinter fields(*this, "SchemaDefinition", node); + fields.printNullablePluralField("directives", node.getDirectives()); + fields.printPluralField("operationTypes", node.getOperationTypes()); + + endVisitNode(fields.finishPrinting()); +} + +bool JsonVisitor::visitOperationTypeDefinition(const OperationTypeDefinition &node) { + visitNode(); + return true; +} + +void JsonVisitor::endVisitOperationTypeDefinition(const OperationTypeDefinition &node) { + NodeFieldPrinter fields(*this, "OperationTypeDefinition", node); + fields.printSingularPrimitiveField("operation", node.getOperation()); + fields.printSingularObjectField("type"); + + endVisitNode(fields.finishPrinting()); +} + +bool JsonVisitor::visitScalarTypeDefinition(const ScalarTypeDefinition &node) { + visitNode(); + return true; +} + +void JsonVisitor::endVisitScalarTypeDefinition(const ScalarTypeDefinition &node) { + NodeFieldPrinter fields(*this, "ScalarTypeDefinition", node); + fields.printSingularObjectField("name"); + fields.printNullablePluralField("directives", node.getDirectives()); + + endVisitNode(fields.finishPrinting()); +} + +bool JsonVisitor::visitObjectTypeDefinition(const ObjectTypeDefinition &node) { + visitNode(); + return true; +} + +void JsonVisitor::endVisitObjectTypeDefinition(const ObjectTypeDefinition &node) { + NodeFieldPrinter fields(*this, "ObjectTypeDefinition", node); + fields.printSingularObjectField("name"); + fields.printNullablePluralField("interfaces", node.getInterfaces()); + fields.printNullablePluralField("directives", node.getDirectives()); + fields.printPluralField("fields", node.getFields()); + + endVisitNode(fields.finishPrinting()); +} + +bool JsonVisitor::visitFieldDefinition(const FieldDefinition &node) { + visitNode(); + return true; +} + +void JsonVisitor::endVisitFieldDefinition(const FieldDefinition &node) { + NodeFieldPrinter fields(*this, "FieldDefinition", node); + fields.printSingularObjectField("name"); + fields.printNullablePluralField("arguments", node.getArguments()); + fields.printSingularObjectField("type"); + fields.printNullablePluralField("directives", node.getDirectives()); + + endVisitNode(fields.finishPrinting()); +} + +bool JsonVisitor::visitInputValueDefinition(const InputValueDefinition &node) { + visitNode(); + return true; +} + +void JsonVisitor::endVisitInputValueDefinition(const InputValueDefinition &node) { + NodeFieldPrinter fields(*this, "InputValueDefinition", node); + fields.printSingularObjectField("name"); + fields.printSingularObjectField("type"); + fields.printNullableSingularObjectField("defaultValue", node.getDefaultValue()); + fields.printNullablePluralField("directives", node.getDirectives()); + + endVisitNode(fields.finishPrinting()); +} + +bool JsonVisitor::visitInterfaceTypeDefinition(const InterfaceTypeDefinition &node) { + visitNode(); + return true; +} + +void JsonVisitor::endVisitInterfaceTypeDefinition(const InterfaceTypeDefinition &node) { + NodeFieldPrinter fields(*this, "InterfaceTypeDefinition", node); + fields.printSingularObjectField("name"); + fields.printNullablePluralField("directives", node.getDirectives()); + fields.printPluralField("fields", node.getFields()); + + endVisitNode(fields.finishPrinting()); +} + +bool JsonVisitor::visitUnionTypeDefinition(const UnionTypeDefinition &node) { + visitNode(); + return true; +} + +void JsonVisitor::endVisitUnionTypeDefinition(const UnionTypeDefinition &node) { + NodeFieldPrinter fields(*this, "UnionTypeDefinition", node); + fields.printSingularObjectField("name"); + fields.printNullablePluralField("directives", node.getDirectives()); + fields.printPluralField("types", node.getTypes()); + + endVisitNode(fields.finishPrinting()); +} + +bool JsonVisitor::visitEnumTypeDefinition(const EnumTypeDefinition &node) { + visitNode(); + return true; +} + +void JsonVisitor::endVisitEnumTypeDefinition(const EnumTypeDefinition &node) { + NodeFieldPrinter fields(*this, "EnumTypeDefinition", node); + fields.printSingularObjectField("name"); + fields.printNullablePluralField("directives", node.getDirectives()); + fields.printPluralField("values", node.getValues()); + + endVisitNode(fields.finishPrinting()); +} + +bool JsonVisitor::visitEnumValueDefinition(const EnumValueDefinition &node) { + visitNode(); + return true; +} + +void JsonVisitor::endVisitEnumValueDefinition(const EnumValueDefinition &node) { + NodeFieldPrinter fields(*this, "EnumValueDefinition", node); + fields.printSingularObjectField("name"); + fields.printNullablePluralField("directives", node.getDirectives()); + + endVisitNode(fields.finishPrinting()); +} + +bool JsonVisitor::visitInputObjectTypeDefinition(const InputObjectTypeDefinition &node) { + visitNode(); + return true; +} + +void JsonVisitor::endVisitInputObjectTypeDefinition(const InputObjectTypeDefinition &node) { + NodeFieldPrinter fields(*this, "InputObjectTypeDefinition", node); + fields.printSingularObjectField("name"); + fields.printNullablePluralField("directives", node.getDirectives()); + fields.printPluralField("fields", node.getFields()); + + endVisitNode(fields.finishPrinting()); +} + +bool JsonVisitor::visitTypeExtensionDefinition(const TypeExtensionDefinition &node) { + visitNode(); + return true; +} + +void JsonVisitor::endVisitTypeExtensionDefinition(const TypeExtensionDefinition &node) { + NodeFieldPrinter fields(*this, "TypeExtensionDefinition", node); + fields.printSingularObjectField("definition"); + + endVisitNode(fields.finishPrinting()); +} + +bool JsonVisitor::visitDirectiveDefinition(const DirectiveDefinition &node) { + visitNode(); + return true; +} + +void JsonVisitor::endVisitDirectiveDefinition(const DirectiveDefinition &node) { + NodeFieldPrinter fields(*this, "DirectiveDefinition", node); + fields.printSingularObjectField("name"); + fields.printNullablePluralField("arguments", node.getArguments()); + fields.printPluralField("locations", node.getLocations()); + + endVisitNode(fields.finishPrinting()); +} + diff --git a/pregenerated_ast/JsonVisitor.h.inc b/pregenerated_ast/JsonVisitor.h.inc new file mode 100644 index 0000000..7488bda --- /dev/null +++ b/pregenerated_ast/JsonVisitor.h.inc @@ -0,0 +1,110 @@ +/** + * Copyright 2019-present GraphQL Foundation + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +/** @generated */ +bool visitDocument(const Document &node) override; +void endVisitDocument(const Document &node) override; + +bool visitOperationDefinition(const OperationDefinition &node) override; +void endVisitOperationDefinition(const OperationDefinition &node) override; + +bool visitVariableDefinition(const VariableDefinition &node) override; +void endVisitVariableDefinition(const VariableDefinition &node) override; + +bool visitSelectionSet(const SelectionSet &node) override; +void endVisitSelectionSet(const SelectionSet &node) override; + +bool visitField(const Field &node) override; +void endVisitField(const Field &node) override; + +bool visitArgument(const Argument &node) override; +void endVisitArgument(const Argument &node) override; + +bool visitFragmentSpread(const FragmentSpread &node) override; +void endVisitFragmentSpread(const FragmentSpread &node) override; + +bool visitInlineFragment(const InlineFragment &node) override; +void endVisitInlineFragment(const InlineFragment &node) override; + +bool visitFragmentDefinition(const FragmentDefinition &node) override; +void endVisitFragmentDefinition(const FragmentDefinition &node) override; + +bool visitVariable(const Variable &node) override; +void endVisitVariable(const Variable &node) override; + +void endVisitIntValue(const IntValue &node) override; + +void endVisitFloatValue(const FloatValue &node) override; + +void endVisitStringValue(const StringValue &node) override; + +void endVisitBooleanValue(const BooleanValue &node) override; + +void endVisitNullValue(const NullValue &node) override; + +void endVisitEnumValue(const EnumValue &node) override; + +bool visitListValue(const ListValue &node) override; +void endVisitListValue(const ListValue &node) override; + +bool visitObjectValue(const ObjectValue &node) override; +void endVisitObjectValue(const ObjectValue &node) override; + +bool visitObjectField(const ObjectField &node) override; +void endVisitObjectField(const ObjectField &node) override; + +bool visitDirective(const Directive &node) override; +void endVisitDirective(const Directive &node) override; + +bool visitNamedType(const NamedType &node) override; +void endVisitNamedType(const NamedType &node) override; + +bool visitListType(const ListType &node) override; +void endVisitListType(const ListType &node) override; + +bool visitNonNullType(const NonNullType &node) override; +void endVisitNonNullType(const NonNullType &node) override; + +void endVisitName(const Name &node) override; + +bool visitSchemaDefinition(const SchemaDefinition &node) override; +void endVisitSchemaDefinition(const SchemaDefinition &node) override; + +bool visitOperationTypeDefinition(const OperationTypeDefinition &node) override; +void endVisitOperationTypeDefinition(const OperationTypeDefinition &node) override; + +bool visitScalarTypeDefinition(const ScalarTypeDefinition &node) override; +void endVisitScalarTypeDefinition(const ScalarTypeDefinition &node) override; + +bool visitObjectTypeDefinition(const ObjectTypeDefinition &node) override; +void endVisitObjectTypeDefinition(const ObjectTypeDefinition &node) override; + +bool visitFieldDefinition(const FieldDefinition &node) override; +void endVisitFieldDefinition(const FieldDefinition &node) override; + +bool visitInputValueDefinition(const InputValueDefinition &node) override; +void endVisitInputValueDefinition(const InputValueDefinition &node) override; + +bool visitInterfaceTypeDefinition(const InterfaceTypeDefinition &node) override; +void endVisitInterfaceTypeDefinition(const InterfaceTypeDefinition &node) override; + +bool visitUnionTypeDefinition(const UnionTypeDefinition &node) override; +void endVisitUnionTypeDefinition(const UnionTypeDefinition &node) override; + +bool visitEnumTypeDefinition(const EnumTypeDefinition &node) override; +void endVisitEnumTypeDefinition(const EnumTypeDefinition &node) override; + +bool visitEnumValueDefinition(const EnumValueDefinition &node) override; +void endVisitEnumValueDefinition(const EnumValueDefinition &node) override; + +bool visitInputObjectTypeDefinition(const InputObjectTypeDefinition &node) override; +void endVisitInputObjectTypeDefinition(const InputObjectTypeDefinition &node) override; + +bool visitTypeExtensionDefinition(const TypeExtensionDefinition &node) override; +void endVisitTypeExtensionDefinition(const TypeExtensionDefinition &node) override; + +bool visitDirectiveDefinition(const DirectiveDefinition &node) override; +void endVisitDirectiveDefinition(const DirectiveDefinition &node) override; + diff --git a/pregenerated_ast/c/GraphQLAst.cpp b/pregenerated_ast/c/GraphQLAst.cpp new file mode 100644 index 0000000..adf14d1 --- /dev/null +++ b/pregenerated_ast/c/GraphQLAst.cpp @@ -0,0 +1,324 @@ +/** + * Copyright 2019-present GraphQL Foundation + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +/** @generated */ + +#include "GraphQLAst.h" +#include "../Ast.h" + +using namespace facebook::graphql::ast; // NOLINT + +int GraphQLAstDocument_get_definitions_size(const struct GraphQLAstDocument *node) { + const auto *realNode = reinterpret_cast(node); + return realNode->getDefinitions().size(); +} +const char * GraphQLAstOperationDefinition_get_operation(const struct GraphQLAstOperationDefinition *node) { + const auto *realNode = reinterpret_cast(node); + return realNode->getOperation(); +} +const struct GraphQLAstName * GraphQLAstOperationDefinition_get_name(const struct GraphQLAstOperationDefinition *node) { + const auto *realNode = reinterpret_cast(node); + return reinterpret_cast(realNode->getName()); +} +int GraphQLAstOperationDefinition_get_variable_definitions_size(const struct GraphQLAstOperationDefinition *node) { + const auto *realNode = reinterpret_cast(node); + return realNode->getVariableDefinitions() ? realNode->getVariableDefinitions()->size() : 0; +} +int GraphQLAstOperationDefinition_get_directives_size(const struct GraphQLAstOperationDefinition *node) { + const auto *realNode = reinterpret_cast(node); + return realNode->getDirectives() ? realNode->getDirectives()->size() : 0; +} +const struct GraphQLAstSelectionSet * GraphQLAstOperationDefinition_get_selection_set(const struct GraphQLAstOperationDefinition *node) { + const auto *realNode = reinterpret_cast(node); + return reinterpret_cast(&realNode->getSelectionSet()); +} +const struct GraphQLAstVariable * GraphQLAstVariableDefinition_get_variable(const struct GraphQLAstVariableDefinition *node) { + const auto *realNode = reinterpret_cast(node); + return reinterpret_cast(&realNode->getVariable()); +} +const struct GraphQLAstType * GraphQLAstVariableDefinition_get_type(const struct GraphQLAstVariableDefinition *node) { + const auto *realNode = reinterpret_cast(node); + return reinterpret_cast(&realNode->getType()); +} +const struct GraphQLAstValue * GraphQLAstVariableDefinition_get_default_value(const struct GraphQLAstVariableDefinition *node) { + const auto *realNode = reinterpret_cast(node); + return reinterpret_cast(realNode->getDefaultValue()); +} +int GraphQLAstSelectionSet_get_selections_size(const struct GraphQLAstSelectionSet *node) { + const auto *realNode = reinterpret_cast(node); + return realNode->getSelections().size(); +} +const struct GraphQLAstName * GraphQLAstField_get_alias(const struct GraphQLAstField *node) { + const auto *realNode = reinterpret_cast(node); + return reinterpret_cast(realNode->getAlias()); +} +const struct GraphQLAstName * GraphQLAstField_get_name(const struct GraphQLAstField *node) { + const auto *realNode = reinterpret_cast(node); + return reinterpret_cast(&realNode->getName()); +} +int GraphQLAstField_get_arguments_size(const struct GraphQLAstField *node) { + const auto *realNode = reinterpret_cast(node); + return realNode->getArguments() ? realNode->getArguments()->size() : 0; +} +int GraphQLAstField_get_directives_size(const struct GraphQLAstField *node) { + const auto *realNode = reinterpret_cast(node); + return realNode->getDirectives() ? realNode->getDirectives()->size() : 0; +} +const struct GraphQLAstSelectionSet * GraphQLAstField_get_selection_set(const struct GraphQLAstField *node) { + const auto *realNode = reinterpret_cast(node); + return reinterpret_cast(realNode->getSelectionSet()); +} +const struct GraphQLAstName * GraphQLAstArgument_get_name(const struct GraphQLAstArgument *node) { + const auto *realNode = reinterpret_cast(node); + return reinterpret_cast(&realNode->getName()); +} +const struct GraphQLAstValue * GraphQLAstArgument_get_value(const struct GraphQLAstArgument *node) { + const auto *realNode = reinterpret_cast(node); + return reinterpret_cast(&realNode->getValue()); +} +const struct GraphQLAstName * GraphQLAstFragmentSpread_get_name(const struct GraphQLAstFragmentSpread *node) { + const auto *realNode = reinterpret_cast(node); + return reinterpret_cast(&realNode->getName()); +} +int GraphQLAstFragmentSpread_get_directives_size(const struct GraphQLAstFragmentSpread *node) { + const auto *realNode = reinterpret_cast(node); + return realNode->getDirectives() ? realNode->getDirectives()->size() : 0; +} +const struct GraphQLAstNamedType * GraphQLAstInlineFragment_get_type_condition(const struct GraphQLAstInlineFragment *node) { + const auto *realNode = reinterpret_cast(node); + return reinterpret_cast(realNode->getTypeCondition()); +} +int GraphQLAstInlineFragment_get_directives_size(const struct GraphQLAstInlineFragment *node) { + const auto *realNode = reinterpret_cast(node); + return realNode->getDirectives() ? realNode->getDirectives()->size() : 0; +} +const struct GraphQLAstSelectionSet * GraphQLAstInlineFragment_get_selection_set(const struct GraphQLAstInlineFragment *node) { + const auto *realNode = reinterpret_cast(node); + return reinterpret_cast(&realNode->getSelectionSet()); +} +const struct GraphQLAstName * GraphQLAstFragmentDefinition_get_name(const struct GraphQLAstFragmentDefinition *node) { + const auto *realNode = reinterpret_cast(node); + return reinterpret_cast(&realNode->getName()); +} +const struct GraphQLAstNamedType * GraphQLAstFragmentDefinition_get_type_condition(const struct GraphQLAstFragmentDefinition *node) { + const auto *realNode = reinterpret_cast(node); + return reinterpret_cast(&realNode->getTypeCondition()); +} +int GraphQLAstFragmentDefinition_get_directives_size(const struct GraphQLAstFragmentDefinition *node) { + const auto *realNode = reinterpret_cast(node); + return realNode->getDirectives() ? realNode->getDirectives()->size() : 0; +} +const struct GraphQLAstSelectionSet * GraphQLAstFragmentDefinition_get_selection_set(const struct GraphQLAstFragmentDefinition *node) { + const auto *realNode = reinterpret_cast(node); + return reinterpret_cast(&realNode->getSelectionSet()); +} +const struct GraphQLAstName * GraphQLAstVariable_get_name(const struct GraphQLAstVariable *node) { + const auto *realNode = reinterpret_cast(node); + return reinterpret_cast(&realNode->getName()); +} +const char * GraphQLAstIntValue_get_value(const struct GraphQLAstIntValue *node) { + const auto *realNode = reinterpret_cast(node); + return realNode->getValue(); +} +const char * GraphQLAstFloatValue_get_value(const struct GraphQLAstFloatValue *node) { + const auto *realNode = reinterpret_cast(node); + return realNode->getValue(); +} +const char * GraphQLAstStringValue_get_value(const struct GraphQLAstStringValue *node) { + const auto *realNode = reinterpret_cast(node); + return realNode->getValue(); +} +int GraphQLAstBooleanValue_get_value(const struct GraphQLAstBooleanValue *node) { + const auto *realNode = reinterpret_cast(node); + return realNode->getValue(); +} +const char * GraphQLAstEnumValue_get_value(const struct GraphQLAstEnumValue *node) { + const auto *realNode = reinterpret_cast(node); + return realNode->getValue(); +} +int GraphQLAstListValue_get_values_size(const struct GraphQLAstListValue *node) { + const auto *realNode = reinterpret_cast(node); + return realNode->getValues().size(); +} +int GraphQLAstObjectValue_get_fields_size(const struct GraphQLAstObjectValue *node) { + const auto *realNode = reinterpret_cast(node); + return realNode->getFields().size(); +} +const struct GraphQLAstName * GraphQLAstObjectField_get_name(const struct GraphQLAstObjectField *node) { + const auto *realNode = reinterpret_cast(node); + return reinterpret_cast(&realNode->getName()); +} +const struct GraphQLAstValue * GraphQLAstObjectField_get_value(const struct GraphQLAstObjectField *node) { + const auto *realNode = reinterpret_cast(node); + return reinterpret_cast(&realNode->getValue()); +} +const struct GraphQLAstName * GraphQLAstDirective_get_name(const struct GraphQLAstDirective *node) { + const auto *realNode = reinterpret_cast(node); + return reinterpret_cast(&realNode->getName()); +} +int GraphQLAstDirective_get_arguments_size(const struct GraphQLAstDirective *node) { + const auto *realNode = reinterpret_cast(node); + return realNode->getArguments() ? realNode->getArguments()->size() : 0; +} +const struct GraphQLAstName * GraphQLAstNamedType_get_name(const struct GraphQLAstNamedType *node) { + const auto *realNode = reinterpret_cast(node); + return reinterpret_cast(&realNode->getName()); +} +const struct GraphQLAstType * GraphQLAstListType_get_type(const struct GraphQLAstListType *node) { + const auto *realNode = reinterpret_cast(node); + return reinterpret_cast(&realNode->getType()); +} +const struct GraphQLAstType * GraphQLAstNonNullType_get_type(const struct GraphQLAstNonNullType *node) { + const auto *realNode = reinterpret_cast(node); + return reinterpret_cast(&realNode->getType()); +} +const char * GraphQLAstName_get_value(const struct GraphQLAstName *node) { + const auto *realNode = reinterpret_cast(node); + return realNode->getValue(); +} +int GraphQLAstSchemaDefinition_get_directives_size(const struct GraphQLAstSchemaDefinition *node) { + const auto *realNode = reinterpret_cast(node); + return realNode->getDirectives() ? realNode->getDirectives()->size() : 0; +} +int GraphQLAstSchemaDefinition_get_operation_types_size(const struct GraphQLAstSchemaDefinition *node) { + const auto *realNode = reinterpret_cast(node); + return realNode->getOperationTypes().size(); +} +const char * GraphQLAstOperationTypeDefinition_get_operation(const struct GraphQLAstOperationTypeDefinition *node) { + const auto *realNode = reinterpret_cast(node); + return realNode->getOperation(); +} +const struct GraphQLAstNamedType * GraphQLAstOperationTypeDefinition_get_type(const struct GraphQLAstOperationTypeDefinition *node) { + const auto *realNode = reinterpret_cast(node); + return reinterpret_cast(&realNode->getType()); +} +const struct GraphQLAstName * GraphQLAstScalarTypeDefinition_get_name(const struct GraphQLAstScalarTypeDefinition *node) { + const auto *realNode = reinterpret_cast(node); + return reinterpret_cast(&realNode->getName()); +} +int GraphQLAstScalarTypeDefinition_get_directives_size(const struct GraphQLAstScalarTypeDefinition *node) { + const auto *realNode = reinterpret_cast(node); + return realNode->getDirectives() ? realNode->getDirectives()->size() : 0; +} +const struct GraphQLAstName * GraphQLAstObjectTypeDefinition_get_name(const struct GraphQLAstObjectTypeDefinition *node) { + const auto *realNode = reinterpret_cast(node); + return reinterpret_cast(&realNode->getName()); +} +int GraphQLAstObjectTypeDefinition_get_interfaces_size(const struct GraphQLAstObjectTypeDefinition *node) { + const auto *realNode = reinterpret_cast(node); + return realNode->getInterfaces() ? realNode->getInterfaces()->size() : 0; +} +int GraphQLAstObjectTypeDefinition_get_directives_size(const struct GraphQLAstObjectTypeDefinition *node) { + const auto *realNode = reinterpret_cast(node); + return realNode->getDirectives() ? realNode->getDirectives()->size() : 0; +} +int GraphQLAstObjectTypeDefinition_get_fields_size(const struct GraphQLAstObjectTypeDefinition *node) { + const auto *realNode = reinterpret_cast(node); + return realNode->getFields().size(); +} +const struct GraphQLAstName * GraphQLAstFieldDefinition_get_name(const struct GraphQLAstFieldDefinition *node) { + const auto *realNode = reinterpret_cast(node); + return reinterpret_cast(&realNode->getName()); +} +int GraphQLAstFieldDefinition_get_arguments_size(const struct GraphQLAstFieldDefinition *node) { + const auto *realNode = reinterpret_cast(node); + return realNode->getArguments() ? realNode->getArguments()->size() : 0; +} +const struct GraphQLAstType * GraphQLAstFieldDefinition_get_type(const struct GraphQLAstFieldDefinition *node) { + const auto *realNode = reinterpret_cast(node); + return reinterpret_cast(&realNode->getType()); +} +int GraphQLAstFieldDefinition_get_directives_size(const struct GraphQLAstFieldDefinition *node) { + const auto *realNode = reinterpret_cast(node); + return realNode->getDirectives() ? realNode->getDirectives()->size() : 0; +} +const struct GraphQLAstName * GraphQLAstInputValueDefinition_get_name(const struct GraphQLAstInputValueDefinition *node) { + const auto *realNode = reinterpret_cast(node); + return reinterpret_cast(&realNode->getName()); +} +const struct GraphQLAstType * GraphQLAstInputValueDefinition_get_type(const struct GraphQLAstInputValueDefinition *node) { + const auto *realNode = reinterpret_cast(node); + return reinterpret_cast(&realNode->getType()); +} +const struct GraphQLAstValue * GraphQLAstInputValueDefinition_get_default_value(const struct GraphQLAstInputValueDefinition *node) { + const auto *realNode = reinterpret_cast(node); + return reinterpret_cast(realNode->getDefaultValue()); +} +int GraphQLAstInputValueDefinition_get_directives_size(const struct GraphQLAstInputValueDefinition *node) { + const auto *realNode = reinterpret_cast(node); + return realNode->getDirectives() ? realNode->getDirectives()->size() : 0; +} +const struct GraphQLAstName * GraphQLAstInterfaceTypeDefinition_get_name(const struct GraphQLAstInterfaceTypeDefinition *node) { + const auto *realNode = reinterpret_cast(node); + return reinterpret_cast(&realNode->getName()); +} +int GraphQLAstInterfaceTypeDefinition_get_directives_size(const struct GraphQLAstInterfaceTypeDefinition *node) { + const auto *realNode = reinterpret_cast(node); + return realNode->getDirectives() ? realNode->getDirectives()->size() : 0; +} +int GraphQLAstInterfaceTypeDefinition_get_fields_size(const struct GraphQLAstInterfaceTypeDefinition *node) { + const auto *realNode = reinterpret_cast(node); + return realNode->getFields().size(); +} +const struct GraphQLAstName * GraphQLAstUnionTypeDefinition_get_name(const struct GraphQLAstUnionTypeDefinition *node) { + const auto *realNode = reinterpret_cast(node); + return reinterpret_cast(&realNode->getName()); +} +int GraphQLAstUnionTypeDefinition_get_directives_size(const struct GraphQLAstUnionTypeDefinition *node) { + const auto *realNode = reinterpret_cast(node); + return realNode->getDirectives() ? realNode->getDirectives()->size() : 0; +} +int GraphQLAstUnionTypeDefinition_get_types_size(const struct GraphQLAstUnionTypeDefinition *node) { + const auto *realNode = reinterpret_cast(node); + return realNode->getTypes().size(); +} +const struct GraphQLAstName * GraphQLAstEnumTypeDefinition_get_name(const struct GraphQLAstEnumTypeDefinition *node) { + const auto *realNode = reinterpret_cast(node); + return reinterpret_cast(&realNode->getName()); +} +int GraphQLAstEnumTypeDefinition_get_directives_size(const struct GraphQLAstEnumTypeDefinition *node) { + const auto *realNode = reinterpret_cast(node); + return realNode->getDirectives() ? realNode->getDirectives()->size() : 0; +} +int GraphQLAstEnumTypeDefinition_get_values_size(const struct GraphQLAstEnumTypeDefinition *node) { + const auto *realNode = reinterpret_cast(node); + return realNode->getValues().size(); +} +const struct GraphQLAstName * GraphQLAstEnumValueDefinition_get_name(const struct GraphQLAstEnumValueDefinition *node) { + const auto *realNode = reinterpret_cast(node); + return reinterpret_cast(&realNode->getName()); +} +int GraphQLAstEnumValueDefinition_get_directives_size(const struct GraphQLAstEnumValueDefinition *node) { + const auto *realNode = reinterpret_cast(node); + return realNode->getDirectives() ? realNode->getDirectives()->size() : 0; +} +const struct GraphQLAstName * GraphQLAstInputObjectTypeDefinition_get_name(const struct GraphQLAstInputObjectTypeDefinition *node) { + const auto *realNode = reinterpret_cast(node); + return reinterpret_cast(&realNode->getName()); +} +int GraphQLAstInputObjectTypeDefinition_get_directives_size(const struct GraphQLAstInputObjectTypeDefinition *node) { + const auto *realNode = reinterpret_cast(node); + return realNode->getDirectives() ? realNode->getDirectives()->size() : 0; +} +int GraphQLAstInputObjectTypeDefinition_get_fields_size(const struct GraphQLAstInputObjectTypeDefinition *node) { + const auto *realNode = reinterpret_cast(node); + return realNode->getFields().size(); +} +const struct GraphQLAstObjectTypeDefinition * GraphQLAstTypeExtensionDefinition_get_definition(const struct GraphQLAstTypeExtensionDefinition *node) { + const auto *realNode = reinterpret_cast(node); + return reinterpret_cast(&realNode->getDefinition()); +} +const struct GraphQLAstName * GraphQLAstDirectiveDefinition_get_name(const struct GraphQLAstDirectiveDefinition *node) { + const auto *realNode = reinterpret_cast(node); + return reinterpret_cast(&realNode->getName()); +} +int GraphQLAstDirectiveDefinition_get_arguments_size(const struct GraphQLAstDirectiveDefinition *node) { + const auto *realNode = reinterpret_cast(node); + return realNode->getArguments() ? realNode->getArguments()->size() : 0; +} +int GraphQLAstDirectiveDefinition_get_locations_size(const struct GraphQLAstDirectiveDefinition *node) { + const auto *realNode = reinterpret_cast(node); + return realNode->getLocations().size(); +} diff --git a/pregenerated_ast/c/GraphQLAst.h b/pregenerated_ast/c/GraphQLAst.h new file mode 100644 index 0000000..fa0292b --- /dev/null +++ b/pregenerated_ast/c/GraphQLAst.h @@ -0,0 +1,180 @@ +/** + * Copyright 2019-present GraphQL Foundation + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +/** @generated */ + +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif + + +struct GraphQLAstDefinition; + +struct GraphQLAstDocument; +int GraphQLAstDocument_get_definitions_size(const struct GraphQLAstDocument *node); + +struct GraphQLAstOperationDefinition; +const char * GraphQLAstOperationDefinition_get_operation(const struct GraphQLAstOperationDefinition *node); +const struct GraphQLAstName * GraphQLAstOperationDefinition_get_name(const struct GraphQLAstOperationDefinition *node); +int GraphQLAstOperationDefinition_get_variable_definitions_size(const struct GraphQLAstOperationDefinition *node); +int GraphQLAstOperationDefinition_get_directives_size(const struct GraphQLAstOperationDefinition *node); +const struct GraphQLAstSelectionSet * GraphQLAstOperationDefinition_get_selection_set(const struct GraphQLAstOperationDefinition *node); + +struct GraphQLAstVariableDefinition; +const struct GraphQLAstVariable * GraphQLAstVariableDefinition_get_variable(const struct GraphQLAstVariableDefinition *node); +const struct GraphQLAstType * GraphQLAstVariableDefinition_get_type(const struct GraphQLAstVariableDefinition *node); +const struct GraphQLAstValue * GraphQLAstVariableDefinition_get_default_value(const struct GraphQLAstVariableDefinition *node); + +struct GraphQLAstSelectionSet; +int GraphQLAstSelectionSet_get_selections_size(const struct GraphQLAstSelectionSet *node); + +struct GraphQLAstSelection; + +struct GraphQLAstField; +const struct GraphQLAstName * GraphQLAstField_get_alias(const struct GraphQLAstField *node); +const struct GraphQLAstName * GraphQLAstField_get_name(const struct GraphQLAstField *node); +int GraphQLAstField_get_arguments_size(const struct GraphQLAstField *node); +int GraphQLAstField_get_directives_size(const struct GraphQLAstField *node); +const struct GraphQLAstSelectionSet * GraphQLAstField_get_selection_set(const struct GraphQLAstField *node); + +struct GraphQLAstArgument; +const struct GraphQLAstName * GraphQLAstArgument_get_name(const struct GraphQLAstArgument *node); +const struct GraphQLAstValue * GraphQLAstArgument_get_value(const struct GraphQLAstArgument *node); + +struct GraphQLAstFragmentSpread; +const struct GraphQLAstName * GraphQLAstFragmentSpread_get_name(const struct GraphQLAstFragmentSpread *node); +int GraphQLAstFragmentSpread_get_directives_size(const struct GraphQLAstFragmentSpread *node); + +struct GraphQLAstInlineFragment; +const struct GraphQLAstNamedType * GraphQLAstInlineFragment_get_type_condition(const struct GraphQLAstInlineFragment *node); +int GraphQLAstInlineFragment_get_directives_size(const struct GraphQLAstInlineFragment *node); +const struct GraphQLAstSelectionSet * GraphQLAstInlineFragment_get_selection_set(const struct GraphQLAstInlineFragment *node); + +struct GraphQLAstFragmentDefinition; +const struct GraphQLAstName * GraphQLAstFragmentDefinition_get_name(const struct GraphQLAstFragmentDefinition *node); +const struct GraphQLAstNamedType * GraphQLAstFragmentDefinition_get_type_condition(const struct GraphQLAstFragmentDefinition *node); +int GraphQLAstFragmentDefinition_get_directives_size(const struct GraphQLAstFragmentDefinition *node); +const struct GraphQLAstSelectionSet * GraphQLAstFragmentDefinition_get_selection_set(const struct GraphQLAstFragmentDefinition *node); + +struct GraphQLAstValue; + +struct GraphQLAstVariable; +const struct GraphQLAstName * GraphQLAstVariable_get_name(const struct GraphQLAstVariable *node); + +struct GraphQLAstIntValue; +const char * GraphQLAstIntValue_get_value(const struct GraphQLAstIntValue *node); + +struct GraphQLAstFloatValue; +const char * GraphQLAstFloatValue_get_value(const struct GraphQLAstFloatValue *node); + +struct GraphQLAstStringValue; +const char * GraphQLAstStringValue_get_value(const struct GraphQLAstStringValue *node); + +struct GraphQLAstBooleanValue; +int GraphQLAstBooleanValue_get_value(const struct GraphQLAstBooleanValue *node); + +struct GraphQLAstNullValue; + +struct GraphQLAstEnumValue; +const char * GraphQLAstEnumValue_get_value(const struct GraphQLAstEnumValue *node); + +struct GraphQLAstListValue; +int GraphQLAstListValue_get_values_size(const struct GraphQLAstListValue *node); + +struct GraphQLAstObjectValue; +int GraphQLAstObjectValue_get_fields_size(const struct GraphQLAstObjectValue *node); + +struct GraphQLAstObjectField; +const struct GraphQLAstName * GraphQLAstObjectField_get_name(const struct GraphQLAstObjectField *node); +const struct GraphQLAstValue * GraphQLAstObjectField_get_value(const struct GraphQLAstObjectField *node); + +struct GraphQLAstDirective; +const struct GraphQLAstName * GraphQLAstDirective_get_name(const struct GraphQLAstDirective *node); +int GraphQLAstDirective_get_arguments_size(const struct GraphQLAstDirective *node); + +struct GraphQLAstType; + +struct GraphQLAstNamedType; +const struct GraphQLAstName * GraphQLAstNamedType_get_name(const struct GraphQLAstNamedType *node); + +struct GraphQLAstListType; +const struct GraphQLAstType * GraphQLAstListType_get_type(const struct GraphQLAstListType *node); + +struct GraphQLAstNonNullType; +const struct GraphQLAstType * GraphQLAstNonNullType_get_type(const struct GraphQLAstNonNullType *node); + +struct GraphQLAstName; +const char * GraphQLAstName_get_value(const struct GraphQLAstName *node); + +struct GraphQLAstSchemaDefinition; +int GraphQLAstSchemaDefinition_get_directives_size(const struct GraphQLAstSchemaDefinition *node); +int GraphQLAstSchemaDefinition_get_operation_types_size(const struct GraphQLAstSchemaDefinition *node); + +struct GraphQLAstOperationTypeDefinition; +const char * GraphQLAstOperationTypeDefinition_get_operation(const struct GraphQLAstOperationTypeDefinition *node); +const struct GraphQLAstNamedType * GraphQLAstOperationTypeDefinition_get_type(const struct GraphQLAstOperationTypeDefinition *node); + +struct GraphQLAstScalarTypeDefinition; +const struct GraphQLAstName * GraphQLAstScalarTypeDefinition_get_name(const struct GraphQLAstScalarTypeDefinition *node); +int GraphQLAstScalarTypeDefinition_get_directives_size(const struct GraphQLAstScalarTypeDefinition *node); + +struct GraphQLAstObjectTypeDefinition; +const struct GraphQLAstName * GraphQLAstObjectTypeDefinition_get_name(const struct GraphQLAstObjectTypeDefinition *node); +int GraphQLAstObjectTypeDefinition_get_interfaces_size(const struct GraphQLAstObjectTypeDefinition *node); +int GraphQLAstObjectTypeDefinition_get_directives_size(const struct GraphQLAstObjectTypeDefinition *node); +int GraphQLAstObjectTypeDefinition_get_fields_size(const struct GraphQLAstObjectTypeDefinition *node); + +struct GraphQLAstFieldDefinition; +const struct GraphQLAstName * GraphQLAstFieldDefinition_get_name(const struct GraphQLAstFieldDefinition *node); +int GraphQLAstFieldDefinition_get_arguments_size(const struct GraphQLAstFieldDefinition *node); +const struct GraphQLAstType * GraphQLAstFieldDefinition_get_type(const struct GraphQLAstFieldDefinition *node); +int GraphQLAstFieldDefinition_get_directives_size(const struct GraphQLAstFieldDefinition *node); + +struct GraphQLAstInputValueDefinition; +const struct GraphQLAstName * GraphQLAstInputValueDefinition_get_name(const struct GraphQLAstInputValueDefinition *node); +const struct GraphQLAstType * GraphQLAstInputValueDefinition_get_type(const struct GraphQLAstInputValueDefinition *node); +const struct GraphQLAstValue * GraphQLAstInputValueDefinition_get_default_value(const struct GraphQLAstInputValueDefinition *node); +int GraphQLAstInputValueDefinition_get_directives_size(const struct GraphQLAstInputValueDefinition *node); + +struct GraphQLAstInterfaceTypeDefinition; +const struct GraphQLAstName * GraphQLAstInterfaceTypeDefinition_get_name(const struct GraphQLAstInterfaceTypeDefinition *node); +int GraphQLAstInterfaceTypeDefinition_get_directives_size(const struct GraphQLAstInterfaceTypeDefinition *node); +int GraphQLAstInterfaceTypeDefinition_get_fields_size(const struct GraphQLAstInterfaceTypeDefinition *node); + +struct GraphQLAstUnionTypeDefinition; +const struct GraphQLAstName * GraphQLAstUnionTypeDefinition_get_name(const struct GraphQLAstUnionTypeDefinition *node); +int GraphQLAstUnionTypeDefinition_get_directives_size(const struct GraphQLAstUnionTypeDefinition *node); +int GraphQLAstUnionTypeDefinition_get_types_size(const struct GraphQLAstUnionTypeDefinition *node); + +struct GraphQLAstEnumTypeDefinition; +const struct GraphQLAstName * GraphQLAstEnumTypeDefinition_get_name(const struct GraphQLAstEnumTypeDefinition *node); +int GraphQLAstEnumTypeDefinition_get_directives_size(const struct GraphQLAstEnumTypeDefinition *node); +int GraphQLAstEnumTypeDefinition_get_values_size(const struct GraphQLAstEnumTypeDefinition *node); + +struct GraphQLAstEnumValueDefinition; +const struct GraphQLAstName * GraphQLAstEnumValueDefinition_get_name(const struct GraphQLAstEnumValueDefinition *node); +int GraphQLAstEnumValueDefinition_get_directives_size(const struct GraphQLAstEnumValueDefinition *node); + +struct GraphQLAstInputObjectTypeDefinition; +const struct GraphQLAstName * GraphQLAstInputObjectTypeDefinition_get_name(const struct GraphQLAstInputObjectTypeDefinition *node); +int GraphQLAstInputObjectTypeDefinition_get_directives_size(const struct GraphQLAstInputObjectTypeDefinition *node); +int GraphQLAstInputObjectTypeDefinition_get_fields_size(const struct GraphQLAstInputObjectTypeDefinition *node); + +struct GraphQLAstTypeExtensionDefinition; +const struct GraphQLAstObjectTypeDefinition * GraphQLAstTypeExtensionDefinition_get_definition(const struct GraphQLAstTypeExtensionDefinition *node); + +struct GraphQLAstDirectiveDefinition; +const struct GraphQLAstName * GraphQLAstDirectiveDefinition_get_name(const struct GraphQLAstDirectiveDefinition *node); +int GraphQLAstDirectiveDefinition_get_arguments_size(const struct GraphQLAstDirectiveDefinition *node); +int GraphQLAstDirectiveDefinition_get_locations_size(const struct GraphQLAstDirectiveDefinition *node); + + + +#ifdef __cplusplus +} +#endif + diff --git a/pregenerated_ast/c/GraphQLAstForEachConcreteType.h b/pregenerated_ast/c/GraphQLAstForEachConcreteType.h new file mode 100644 index 0000000..3e7e839 --- /dev/null +++ b/pregenerated_ast/c/GraphQLAstForEachConcreteType.h @@ -0,0 +1,44 @@ +/** + * Copyright 2019-present GraphQL Foundation + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +/** @generated */ +#define FOR_EACH_CONCRETE_TYPE(MACRO) \ +MACRO(Document, document) \ +MACRO(OperationDefinition, operation_definition) \ +MACRO(VariableDefinition, variable_definition) \ +MACRO(SelectionSet, selection_set) \ +MACRO(Field, field) \ +MACRO(Argument, argument) \ +MACRO(FragmentSpread, fragment_spread) \ +MACRO(InlineFragment, inline_fragment) \ +MACRO(FragmentDefinition, fragment_definition) \ +MACRO(Variable, variable) \ +MACRO(IntValue, int_value) \ +MACRO(FloatValue, float_value) \ +MACRO(StringValue, string_value) \ +MACRO(BooleanValue, boolean_value) \ +MACRO(NullValue, null_value) \ +MACRO(EnumValue, enum_value) \ +MACRO(ListValue, list_value) \ +MACRO(ObjectValue, object_value) \ +MACRO(ObjectField, object_field) \ +MACRO(Directive, directive) \ +MACRO(NamedType, named_type) \ +MACRO(ListType, list_type) \ +MACRO(NonNullType, non_null_type) \ +MACRO(Name, name) \ +MACRO(SchemaDefinition, schema_definition) \ +MACRO(OperationTypeDefinition, operation_type_definition) \ +MACRO(ScalarTypeDefinition, scalar_type_definition) \ +MACRO(ObjectTypeDefinition, object_type_definition) \ +MACRO(FieldDefinition, field_definition) \ +MACRO(InputValueDefinition, input_value_definition) \ +MACRO(InterfaceTypeDefinition, interface_type_definition) \ +MACRO(UnionTypeDefinition, union_type_definition) \ +MACRO(EnumTypeDefinition, enum_type_definition) \ +MACRO(EnumValueDefinition, enum_value_definition) \ +MACRO(InputObjectTypeDefinition, input_object_type_definition) \ +MACRO(TypeExtensionDefinition, type_extension_definition) \ +MACRO(DirectiveDefinition, directive_definition)