tidl

package

Go to main page

Versions in this module

v0

v0.0.3

Oct 3, 2025

Changes in this version

+ const TLexerKW_ONEOF

+ const TLexerNEWLINE

+ const TLexerSEMICOLON

+ const TParserKW_ONEOF

+ const TParserNEWLINE

+ const TParserRULE_oneof_def

+ const TParserRULE_terminator

+ const TParserSEMICOLON

+ func InitEmptyOneof_defContext(p *Oneof_defContext)

+ func InitEmptyTerminatorContext(p *TerminatorContext)

+ func IsPascal(name string) bool

+ func ToPascal(s string) string

type Annotation

+ func GetAnnotation(arr []Annotation, names ...string) (Annotation, bool)

type BaseTParserListener

+ func (s *BaseTParserListener) EnterOneof_def(ctx *Oneof_defContext)

+ func (s *BaseTParserListener) EnterTerminator(ctx *TerminatorContext)

+ func (s *BaseTParserListener) ExitOneof_def(ctx *Oneof_defContext)

+ func (s *BaseTParserListener) ExitTerminator(ctx *TerminatorContext)

type Comments

+ Above []Comment

type DefinitionContext

+ func (s *DefinitionContext) Oneof_def() IOneof_defContext

type Document

+ EnumTypes map[string]int

+ TypeTypes map[string]int

+ UsedTypes map[string]struct{}

type DocumentContext

+ func (s *DocumentContext) AllTerminator() []ITerminatorContext

+ func (s *DocumentContext) Terminator(i int) ITerminatorContext

type Enum

+ func GetEnum(files map[string]Document, name string) (Enum, bool)

type Enum_defContext

+ func (s *Enum_defContext) AllTerminator() []ITerminatorContext

+ func (s *Enum_defContext) Terminator(i int) ITerminatorContext

type ErrorListener

+ Error error

+ Line int

+ Scanner *bufio.Scanner

type IDefinitionContext

+ Oneof_def func() IOneof_defContext

type IDocumentContext

+ AllTerminator func() []ITerminatorContext

+ Terminator func(i int) ITerminatorContext

type IEnum_defContext

+ AllTerminator func() []ITerminatorContext

+ Terminator func(i int) ITerminatorContext

+ type IOneof_defContext interface

+ AllCommon_type_field func() []ICommon_type_fieldContext

+ AllTerminator func() []ITerminatorContext

+ Common_type_field func(i int) ICommon_type_fieldContext

+ GetParser func() antlr.Parser

+ IDENTIFIER func() antlr.TerminalNode

+ IsOneof_defContext func()

+ KW_ONEOF func() antlr.TerminalNode

+ LEFT_BRACE func() antlr.TerminalNode

+ RIGHT_BRACE func() antlr.TerminalNode

+ Terminator func(i int) ITerminatorContext

type IRpc_annotationsContext

+ AllTerminator func() []ITerminatorContext

+ Terminator func(i int) ITerminatorContext

type IRpc_reqContext

+ User_type func() IUser_typeContext

+ type ITerminatorContext interface

+ AllNEWLINE func() []antlr.TerminalNode

+ AllSEMICOLON func() []antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsTerminatorContext func()

+ NEWLINE func(i int) antlr.TerminalNode

+ SEMICOLON func(i int) antlr.TerminalNode

type IType_defContext

+ AllTerminator func() []ITerminatorContext

+ Terminator func(i int) ITerminatorContext

+ Value_type func() IValue_typeContext

type MetaInfo

+ func ParseDir(dir string) (files map[string]Document, meta *MetaInfo, err error)

+ type Oneof_defContext struct

+ func NewEmptyOneof_defContext() *Oneof_defContext

+ func NewOneof_defContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Oneof_defContext

+ func (*Oneof_defContext) IsOneof_defContext()

+ func (s *Oneof_defContext) AllCommon_type_field() []ICommon_type_fieldContext

+ func (s *Oneof_defContext) AllTerminator() []ITerminatorContext

+ func (s *Oneof_defContext) Common_type_field(i int) ICommon_type_fieldContext

+ func (s *Oneof_defContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Oneof_defContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Oneof_defContext) GetParser() antlr.Parser

+ func (s *Oneof_defContext) GetRuleContext() antlr.RuleContext

+ func (s *Oneof_defContext) IDENTIFIER() antlr.TerminalNode

+ func (s *Oneof_defContext) KW_ONEOF() antlr.TerminalNode

+ func (s *Oneof_defContext) LEFT_BRACE() antlr.TerminalNode

+ func (s *Oneof_defContext) RIGHT_BRACE() antlr.TerminalNode

+ func (s *Oneof_defContext) Terminator(i int) ITerminatorContext

+ func (s *Oneof_defContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type ParseTreeListener

+ func (l *ParseTreeListener) ExitOneof_def(ctx *Oneof_defContext)

+ func (l *ParseTreeListener) GetHiddenTokensToLeft(tokenIndex, channel int) []antlr.Token

+ func (l *ParseTreeListener) GetHiddenTokensToRight(tokenIndex, channel int) []antlr.Token

type Rpc_annotationsContext

+ func (s *Rpc_annotationsContext) AllTerminator() []ITerminatorContext

+ func (s *Rpc_annotationsContext) Terminator(i int) ITerminatorContext

type Rpc_reqContext

+ func (s *Rpc_reqContext) User_type() IUser_typeContext

type TParser

+ func (p *TParser) Oneof_def() (localctx IOneof_defContext)

+ func (p *TParser) Terminator() (localctx ITerminatorContext)

type TParserListener

+ EnterOneof_def func(c *Oneof_defContext)

+ EnterTerminator func(c *TerminatorContext)

+ ExitOneof_def func(c *Oneof_defContext)

+ ExitTerminator func(c *TerminatorContext)

+ type TerminatorContext struct

+ func NewEmptyTerminatorContext() *TerminatorContext

+ func NewTerminatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TerminatorContext

+ func (*TerminatorContext) IsTerminatorContext()

+ func (s *TerminatorContext) AllNEWLINE() []antlr.TerminalNode

+ func (s *TerminatorContext) AllSEMICOLON() []antlr.TerminalNode

+ func (s *TerminatorContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *TerminatorContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *TerminatorContext) GetParser() antlr.Parser

+ func (s *TerminatorContext) GetRuleContext() antlr.RuleContext

+ func (s *TerminatorContext) NEWLINE(i int) antlr.TerminalNode

+ func (s *TerminatorContext) SEMICOLON(i int) antlr.TerminalNode

+ func (s *TerminatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

type Type

+ OneOf bool

+ func GetType(files map[string]Document, name string) (Type, bool)

type Type_defContext

+ func (s *Type_defContext) AllTerminator() []ITerminatorContext

+ func (s *Type_defContext) Terminator(i int) ITerminatorContext

+ func (s *Type_defContext) Value_type() IValue_typeContext

v0.0.2

Sep 11, 2025

v0.0.1

Sep 10, 2025

Changes in this version

+ const TLexerCOMMA

+ const TLexerEQUAL

+ const TLexerFLOAT

+ const TLexerGREATER_THAN

+ const TLexerIDENTIFIER

+ const TLexerINTEGER

+ const TLexerKW_CONST

+ const TLexerKW_ENUM

+ const TLexerKW_FALSE

+ const TLexerKW_RPC

+ const TLexerKW_TRUE

+ const TLexerKW_TYPE

+ const TLexerLEFT_BRACE

+ const TLexerLEFT_PAREN

+ const TLexerLESS_THAN

+ const TLexerML_COMMENT_CHAN

+ const TLexerMULTI_LINE_COMMENT

+ const TLexerQUESTION

+ const TLexerRIGHT_BRACE

+ const TLexerRIGHT_PAREN

+ const TLexerSINGLE_LINE_COMMENT

+ const TLexerSL_COMMENT_CHAN

+ const TLexerSTRING

+ const TLexerTYPE_ANY

+ const TLexerTYPE_BINARY

+ const TLexerTYPE_BOOL

+ const TLexerTYPE_FLOAT

+ const TLexerTYPE_INT

+ const TLexerTYPE_LIST

+ const TLexerTYPE_MAP

+ const TLexerTYPE_STREAM

+ const TLexerTYPE_STRING

+ const TLexerWHITESPACE

+ const TLexerWS_CHAN

+ const TParserCOMMA

+ const TParserEOF

+ const TParserEQUAL

+ const TParserFLOAT

+ const TParserGREATER_THAN

+ const TParserIDENTIFIER

+ const TParserINTEGER

+ const TParserKW_CONST

+ const TParserKW_ENUM

+ const TParserKW_FALSE

+ const TParserKW_RPC

+ const TParserKW_TRUE

+ const TParserKW_TYPE

+ const TParserLEFT_BRACE

+ const TParserLEFT_PAREN

+ const TParserLESS_THAN

+ const TParserMULTI_LINE_COMMENT

+ const TParserQUESTION

+ const TParserRIGHT_BRACE

+ const TParserRIGHT_PAREN

+ const TParserRULE_annotation

+ const TParserRULE_base_type

+ const TParserRULE_common_field_type

+ const TParserRULE_common_type_field

+ const TParserRULE_const_def

+ const TParserRULE_const_type

+ const TParserRULE_const_value

+ const TParserRULE_container_type

+ const TParserRULE_definition

+ const TParserRULE_document

+ const TParserRULE_embed_type_field

+ const TParserRULE_enum_def

+ const TParserRULE_enum_field

+ const TParserRULE_generic_type

+ const TParserRULE_key_type

+ const TParserRULE_list_type

+ const TParserRULE_map_type

+ const TParserRULE_rpc_annotations

+ const TParserRULE_rpc_def

+ const TParserRULE_rpc_req

+ const TParserRULE_rpc_resp

+ const TParserRULE_type_annotations

+ const TParserRULE_type_def

+ const TParserRULE_type_field

+ const TParserRULE_user_type

+ const TParserRULE_value_type

+ const TParserSINGLE_LINE_COMMENT

+ const TParserSTRING

+ const TParserTYPE_ANY

+ const TParserTYPE_BINARY

+ const TParserTYPE_BOOL

+ const TParserTYPE_FLOAT

+ const TParserTYPE_INT

+ const TParserTYPE_LIST

+ const TParserTYPE_MAP

+ const TParserTYPE_STREAM

+ const TParserTYPE_STRING

+ const TParserWHITESPACE

+ var TLexerLexerStaticData struct

+ var TParserParserStaticData struct

+ func Dump(doc Document) string

+ func Format(s string) (string, error)

+ func InitEmptyAnnotationContext(p *AnnotationContext)

+ func InitEmptyBase_typeContext(p *Base_typeContext)

+ func InitEmptyCommon_field_typeContext(p *Common_field_typeContext)

+ func InitEmptyCommon_type_fieldContext(p *Common_type_fieldContext)

+ func InitEmptyConst_defContext(p *Const_defContext)

+ func InitEmptyConst_typeContext(p *Const_typeContext)

+ func InitEmptyConst_valueContext(p *Const_valueContext)

+ func InitEmptyContainer_typeContext(p *Container_typeContext)

+ func InitEmptyDefinitionContext(p *DefinitionContext)

+ func InitEmptyDocumentContext(p *DocumentContext)

+ func InitEmptyEmbed_type_fieldContext(p *Embed_type_fieldContext)

+ func InitEmptyEnum_defContext(p *Enum_defContext)

+ func InitEmptyEnum_fieldContext(p *Enum_fieldContext)

+ func InitEmptyGeneric_typeContext(p *Generic_typeContext)

+ func InitEmptyKey_typeContext(p *Key_typeContext)

+ func InitEmptyList_typeContext(p *List_typeContext)

+ func InitEmptyMap_typeContext(p *Map_typeContext)

+ func InitEmptyRpc_annotationsContext(p *Rpc_annotationsContext)

+ func InitEmptyRpc_defContext(p *Rpc_defContext)

+ func InitEmptyRpc_reqContext(p *Rpc_reqContext)

+ func InitEmptyRpc_respContext(p *Rpc_respContext)

+ func InitEmptyType_annotationsContext(p *Type_annotationsContext)

+ func InitEmptyType_defContext(p *Type_defContext)

+ func InitEmptyType_fieldContext(p *Type_fieldContext)

+ func InitEmptyUser_typeContext(p *User_typeContext)

+ func InitEmptyValue_typeContext(p *Value_typeContext)

+ func TLexerInit()

+ func TParserInit()

+ type Annotation struct

+ Comments Comments

+ Key string

+ Position Position

+ Value *string

+ func GetOneOfAnnotation(arr []Annotation, names ...string) (Annotation, bool)

+ type AnnotationContext struct

+ func NewAnnotationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AnnotationContext

+ func NewEmptyAnnotationContext() *AnnotationContext

+ func (*AnnotationContext) IsAnnotationContext()

+ func (s *AnnotationContext) Const_value() IConst_valueContext

+ func (s *AnnotationContext) EQUAL() antlr.TerminalNode

+ func (s *AnnotationContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *AnnotationContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *AnnotationContext) GetParser() antlr.Parser

+ func (s *AnnotationContext) GetRuleContext() antlr.RuleContext

+ func (s *AnnotationContext) IDENTIFIER() antlr.TerminalNode

+ func (s *AnnotationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type AnyType struct

+ func (t AnyType) MarshalText() (text []byte, err error)

+ func (t AnyType) Text() string

+ type BaseTParserListener struct

+ func (s *BaseTParserListener) EnterAnnotation(ctx *AnnotationContext)

+ func (s *BaseTParserListener) EnterBase_type(ctx *Base_typeContext)

+ func (s *BaseTParserListener) EnterCommon_field_type(ctx *Common_field_typeContext)

+ func (s *BaseTParserListener) EnterCommon_type_field(ctx *Common_type_fieldContext)

+ func (s *BaseTParserListener) EnterConst_def(ctx *Const_defContext)

+ func (s *BaseTParserListener) EnterConst_type(ctx *Const_typeContext)

+ func (s *BaseTParserListener) EnterConst_value(ctx *Const_valueContext)

+ func (s *BaseTParserListener) EnterContainer_type(ctx *Container_typeContext)

+ func (s *BaseTParserListener) EnterDefinition(ctx *DefinitionContext)

+ func (s *BaseTParserListener) EnterDocument(ctx *DocumentContext)

+ func (s *BaseTParserListener) EnterEmbed_type_field(ctx *Embed_type_fieldContext)

+ func (s *BaseTParserListener) EnterEnum_def(ctx *Enum_defContext)

+ func (s *BaseTParserListener) EnterEnum_field(ctx *Enum_fieldContext)

+ func (s *BaseTParserListener) EnterEveryRule(ctx antlr.ParserRuleContext)

+ func (s *BaseTParserListener) EnterGeneric_type(ctx *Generic_typeContext)

+ func (s *BaseTParserListener) EnterKey_type(ctx *Key_typeContext)

+ func (s *BaseTParserListener) EnterList_type(ctx *List_typeContext)

+ func (s *BaseTParserListener) EnterMap_type(ctx *Map_typeContext)

+ func (s *BaseTParserListener) EnterRpc_annotations(ctx *Rpc_annotationsContext)

+ func (s *BaseTParserListener) EnterRpc_def(ctx *Rpc_defContext)

+ func (s *BaseTParserListener) EnterRpc_req(ctx *Rpc_reqContext)

+ func (s *BaseTParserListener) EnterRpc_resp(ctx *Rpc_respContext)

+ func (s *BaseTParserListener) EnterType_annotations(ctx *Type_annotationsContext)

+ func (s *BaseTParserListener) EnterType_def(ctx *Type_defContext)

+ func (s *BaseTParserListener) EnterType_field(ctx *Type_fieldContext)

+ func (s *BaseTParserListener) EnterUser_type(ctx *User_typeContext)

+ func (s *BaseTParserListener) EnterValue_type(ctx *Value_typeContext)

+ func (s *BaseTParserListener) ExitAnnotation(ctx *AnnotationContext)

+ func (s *BaseTParserListener) ExitBase_type(ctx *Base_typeContext)

+ func (s *BaseTParserListener) ExitCommon_field_type(ctx *Common_field_typeContext)

+ func (s *BaseTParserListener) ExitCommon_type_field(ctx *Common_type_fieldContext)

+ func (s *BaseTParserListener) ExitConst_def(ctx *Const_defContext)

+ func (s *BaseTParserListener) ExitConst_type(ctx *Const_typeContext)

+ func (s *BaseTParserListener) ExitConst_value(ctx *Const_valueContext)

+ func (s *BaseTParserListener) ExitContainer_type(ctx *Container_typeContext)

+ func (s *BaseTParserListener) ExitDefinition(ctx *DefinitionContext)

+ func (s *BaseTParserListener) ExitDocument(ctx *DocumentContext)

+ func (s *BaseTParserListener) ExitEmbed_type_field(ctx *Embed_type_fieldContext)

+ func (s *BaseTParserListener) ExitEnum_def(ctx *Enum_defContext)

+ func (s *BaseTParserListener) ExitEnum_field(ctx *Enum_fieldContext)

+ func (s *BaseTParserListener) ExitEveryRule(ctx antlr.ParserRuleContext)

+ func (s *BaseTParserListener) ExitGeneric_type(ctx *Generic_typeContext)

+ func (s *BaseTParserListener) ExitKey_type(ctx *Key_typeContext)

+ func (s *BaseTParserListener) ExitList_type(ctx *List_typeContext)

+ func (s *BaseTParserListener) ExitMap_type(ctx *Map_typeContext)

+ func (s *BaseTParserListener) ExitRpc_annotations(ctx *Rpc_annotationsContext)

+ func (s *BaseTParserListener) ExitRpc_def(ctx *Rpc_defContext)

+ func (s *BaseTParserListener) ExitRpc_req(ctx *Rpc_reqContext)

+ func (s *BaseTParserListener) ExitRpc_resp(ctx *Rpc_respContext)

+ func (s *BaseTParserListener) ExitType_annotations(ctx *Type_annotationsContext)

+ func (s *BaseTParserListener) ExitType_def(ctx *Type_defContext)

+ func (s *BaseTParserListener) ExitType_field(ctx *Type_fieldContext)

+ func (s *BaseTParserListener) ExitUser_type(ctx *User_typeContext)

+ func (s *BaseTParserListener) ExitValue_type(ctx *Value_typeContext)

+ func (s *BaseTParserListener) VisitErrorNode(node antlr.ErrorNode)

+ func (s *BaseTParserListener) VisitTerminal(node antlr.TerminalNode)

+ type BaseType struct

+ Name string

+ Optional bool

+ func (t BaseType) Text() string

+ type Base_typeContext struct

+ func NewBase_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Base_typeContext

+ func NewEmptyBase_typeContext() *Base_typeContext

+ func (*Base_typeContext) IsBase_typeContext()

+ func (s *Base_typeContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Base_typeContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Base_typeContext) GetParser() antlr.Parser

+ func (s *Base_typeContext) GetRuleContext() antlr.RuleContext

+ func (s *Base_typeContext) QUESTION() antlr.TerminalNode

+ func (s *Base_typeContext) TYPE_BOOL() antlr.TerminalNode

+ func (s *Base_typeContext) TYPE_FLOAT() antlr.TerminalNode

+ func (s *Base_typeContext) TYPE_INT() antlr.TerminalNode

+ func (s *Base_typeContext) TYPE_STRING() antlr.TerminalNode

+ func (s *Base_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type BinaryType struct

+ func (t BinaryType) MarshalText() (text []byte, err error)

+ func (t BinaryType) Text() string

+ type Comment struct

+ Position Position

+ Single bool

+ Text string

+ type Comments struct

+ Right *Comment

+ Top []Comment

+ type Common_field_typeContext struct

+ func NewCommon_field_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Common_field_typeContext

+ func NewEmptyCommon_field_typeContext() *Common_field_typeContext

+ func (*Common_field_typeContext) IsCommon_field_typeContext()

+ func (s *Common_field_typeContext) Base_type() IBase_typeContext

+ func (s *Common_field_typeContext) Container_type() IContainer_typeContext

+ func (s *Common_field_typeContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Common_field_typeContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Common_field_typeContext) GetParser() antlr.Parser

+ func (s *Common_field_typeContext) GetRuleContext() antlr.RuleContext

+ func (s *Common_field_typeContext) TYPE_ANY() antlr.TerminalNode

+ func (s *Common_field_typeContext) TYPE_BINARY() antlr.TerminalNode

+ func (s *Common_field_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Common_field_typeContext) User_type() IUser_typeContext

+ type Common_type_fieldContext struct

+ func NewCommon_type_fieldContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Common_type_fieldContext

+ func NewEmptyCommon_type_fieldContext() *Common_type_fieldContext

+ func (*Common_type_fieldContext) IsCommon_type_fieldContext()

+ func (s *Common_type_fieldContext) Common_field_type() ICommon_field_typeContext

+ func (s *Common_type_fieldContext) Const_value() IConst_valueContext

+ func (s *Common_type_fieldContext) EQUAL() antlr.TerminalNode

+ func (s *Common_type_fieldContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Common_type_fieldContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Common_type_fieldContext) GetParser() antlr.Parser

+ func (s *Common_type_fieldContext) GetRuleContext() antlr.RuleContext

+ func (s *Common_type_fieldContext) IDENTIFIER() antlr.TerminalNode

+ func (s *Common_type_fieldContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Common_type_fieldContext) Type_annotations() IType_annotationsContext

+ type Const struct

+ Comments Comments

+ Name string

+ Position Position

+ Type string

+ Value string

+ type Const_defContext struct

+ func NewConst_defContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Const_defContext

+ func NewEmptyConst_defContext() *Const_defContext

+ func (*Const_defContext) IsConst_defContext()

+ func (s *Const_defContext) Const_type() IConst_typeContext

+ func (s *Const_defContext) Const_value() IConst_valueContext

+ func (s *Const_defContext) EQUAL() antlr.TerminalNode

+ func (s *Const_defContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Const_defContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Const_defContext) GetParser() antlr.Parser

+ func (s *Const_defContext) GetRuleContext() antlr.RuleContext

+ func (s *Const_defContext) IDENTIFIER() antlr.TerminalNode

+ func (s *Const_defContext) KW_CONST() antlr.TerminalNode

+ func (s *Const_defContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Const_typeContext struct

+ func NewConst_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Const_typeContext

+ func NewEmptyConst_typeContext() *Const_typeContext

+ func (*Const_typeContext) IsConst_typeContext()

+ func (s *Const_typeContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Const_typeContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Const_typeContext) GetParser() antlr.Parser

+ func (s *Const_typeContext) GetRuleContext() antlr.RuleContext

+ func (s *Const_typeContext) TYPE_BOOL() antlr.TerminalNode

+ func (s *Const_typeContext) TYPE_FLOAT() antlr.TerminalNode

+ func (s *Const_typeContext) TYPE_INT() antlr.TerminalNode

+ func (s *Const_typeContext) TYPE_STRING() antlr.TerminalNode

+ func (s *Const_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Const_valueContext struct

+ func NewConst_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Const_valueContext

+ func NewEmptyConst_valueContext() *Const_valueContext

+ func (*Const_valueContext) IsConst_valueContext()

+ func (s *Const_valueContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Const_valueContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Const_valueContext) FLOAT() antlr.TerminalNode

+ func (s *Const_valueContext) GetParser() antlr.Parser

+ func (s *Const_valueContext) GetRuleContext() antlr.RuleContext

+ func (s *Const_valueContext) IDENTIFIER() antlr.TerminalNode

+ func (s *Const_valueContext) INTEGER() antlr.TerminalNode

+ func (s *Const_valueContext) KW_FALSE() antlr.TerminalNode

+ func (s *Const_valueContext) KW_TRUE() antlr.TerminalNode

+ func (s *Const_valueContext) STRING() antlr.TerminalNode

+ func (s *Const_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Container_typeContext struct

+ func NewContainer_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Container_typeContext

+ func NewEmptyContainer_typeContext() *Container_typeContext

+ func (*Container_typeContext) IsContainer_typeContext()

+ func (s *Container_typeContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Container_typeContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Container_typeContext) GetParser() antlr.Parser

+ func (s *Container_typeContext) GetRuleContext() antlr.RuleContext

+ func (s *Container_typeContext) List_type() IList_typeContext

+ func (s *Container_typeContext) Map_type() IMap_typeContext

+ func (s *Container_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type DefinitionContext struct

+ func NewDefinitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DefinitionContext

+ func NewEmptyDefinitionContext() *DefinitionContext

+ func (*DefinitionContext) IsDefinitionContext()

+ func (s *DefinitionContext) Const_def() IConst_defContext

+ func (s *DefinitionContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *DefinitionContext) Enum_def() IEnum_defContext

+ func (s *DefinitionContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *DefinitionContext) GetParser() antlr.Parser

+ func (s *DefinitionContext) GetRuleContext() antlr.RuleContext

+ func (s *DefinitionContext) Rpc_def() IRpc_defContext

+ func (s *DefinitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *DefinitionContext) Type_def() IType_defContext

+ type Document struct

+ Comments []Comment

+ Consts []Const

+ Enums []Enum

+ RPCs []RPC

+ Types []Type

+ func Parse(s string) (doc Document, err error)

+ type DocumentContext struct

+ func NewDocumentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DocumentContext

+ func NewEmptyDocumentContext() *DocumentContext

+ func (*DocumentContext) IsDocumentContext()

+ func (s *DocumentContext) AllDefinition() []IDefinitionContext

+ func (s *DocumentContext) Definition(i int) IDefinitionContext

+ func (s *DocumentContext) EOF() antlr.TerminalNode

+ func (s *DocumentContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *DocumentContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *DocumentContext) GetParser() antlr.Parser

+ func (s *DocumentContext) GetRuleContext() antlr.RuleContext

+ func (s *DocumentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type EmbedType struct

+ Name string

+ Optional bool

+ func (t EmbedType) Text() string

+ type Embed_type_fieldContext struct

+ func NewEmbed_type_fieldContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Embed_type_fieldContext

+ func NewEmptyEmbed_type_fieldContext() *Embed_type_fieldContext

+ func (*Embed_type_fieldContext) IsEmbed_type_fieldContext()

+ func (s *Embed_type_fieldContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Embed_type_fieldContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Embed_type_fieldContext) GetParser() antlr.Parser

+ func (s *Embed_type_fieldContext) GetRuleContext() antlr.RuleContext

+ func (s *Embed_type_fieldContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Embed_type_fieldContext) User_type() IUser_typeContext

+ type Enum struct

+ Comments Comments

+ Fields []EnumField

+ Name string

+ Position Position

+ type EnumField struct

+ Comments Comments

+ Name string

+ Position Position

+ Value int64

+ type Enum_defContext struct

+ func NewEmptyEnum_defContext() *Enum_defContext

+ func NewEnum_defContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Enum_defContext

+ func (*Enum_defContext) IsEnum_defContext()

+ func (s *Enum_defContext) AllEnum_field() []IEnum_fieldContext

+ func (s *Enum_defContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Enum_defContext) Enum_field(i int) IEnum_fieldContext

+ func (s *Enum_defContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Enum_defContext) GetParser() antlr.Parser

+ func (s *Enum_defContext) GetRuleContext() antlr.RuleContext

+ func (s *Enum_defContext) IDENTIFIER() antlr.TerminalNode

+ func (s *Enum_defContext) KW_ENUM() antlr.TerminalNode

+ func (s *Enum_defContext) LEFT_BRACE() antlr.TerminalNode

+ func (s *Enum_defContext) RIGHT_BRACE() antlr.TerminalNode

+ func (s *Enum_defContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Enum_fieldContext struct

+ func NewEmptyEnum_fieldContext() *Enum_fieldContext

+ func NewEnum_fieldContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Enum_fieldContext

+ func (*Enum_fieldContext) IsEnum_fieldContext()

+ func (s *Enum_fieldContext) EQUAL() antlr.TerminalNode

+ func (s *Enum_fieldContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Enum_fieldContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Enum_fieldContext) GetParser() antlr.Parser

+ func (s *Enum_fieldContext) GetRuleContext() antlr.RuleContext

+ func (s *Enum_fieldContext) IDENTIFIER() antlr.TerminalNode

+ func (s *Enum_fieldContext) INTEGER() antlr.TerminalNode

+ func (s *Enum_fieldContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type ErrorListener struct

+ func (l *ErrorListener) SyntaxError(_ antlr.Recognizer, _ any, line, column int, msg string, ...)

+ type Generic_typeContext struct

+ func NewEmptyGeneric_typeContext() *Generic_typeContext

+ func NewGeneric_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Generic_typeContext

+ func (*Generic_typeContext) IsGeneric_typeContext()

+ func (s *Generic_typeContext) Base_type() IBase_typeContext

+ func (s *Generic_typeContext) Container_type() IContainer_typeContext

+ func (s *Generic_typeContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Generic_typeContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Generic_typeContext) GetParser() antlr.Parser

+ func (s *Generic_typeContext) GetRuleContext() antlr.RuleContext

+ func (s *Generic_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Generic_typeContext) User_type() IUser_typeContext

+ type IAnnotationContext interface

+ Const_value func() IConst_valueContext

+ EQUAL func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IDENTIFIER func() antlr.TerminalNode

+ IsAnnotationContext func()

+ type IBase_typeContext interface

+ GetParser func() antlr.Parser

+ IsBase_typeContext func()

+ QUESTION func() antlr.TerminalNode

+ TYPE_BOOL func() antlr.TerminalNode

+ TYPE_FLOAT func() antlr.TerminalNode

+ TYPE_INT func() antlr.TerminalNode

+ TYPE_STRING func() antlr.TerminalNode

+ type ICommon_field_typeContext interface

+ Base_type func() IBase_typeContext

+ Container_type func() IContainer_typeContext

+ GetParser func() antlr.Parser

+ IsCommon_field_typeContext func()

+ TYPE_ANY func() antlr.TerminalNode

+ TYPE_BINARY func() antlr.TerminalNode

+ User_type func() IUser_typeContext

+ type ICommon_type_fieldContext interface

+ Common_field_type func() ICommon_field_typeContext

+ Const_value func() IConst_valueContext

+ EQUAL func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IDENTIFIER func() antlr.TerminalNode

+ IsCommon_type_fieldContext func()

+ Type_annotations func() IType_annotationsContext

+ type IConst_defContext interface

+ Const_type func() IConst_typeContext

+ Const_value func() IConst_valueContext

+ EQUAL func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IDENTIFIER func() antlr.TerminalNode

+ IsConst_defContext func()

+ KW_CONST func() antlr.TerminalNode

+ type IConst_typeContext interface

+ GetParser func() antlr.Parser

+ IsConst_typeContext func()

+ TYPE_BOOL func() antlr.TerminalNode

+ TYPE_FLOAT func() antlr.TerminalNode

+ TYPE_INT func() antlr.TerminalNode

+ TYPE_STRING func() antlr.TerminalNode

+ type IConst_valueContext interface

+ FLOAT func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IDENTIFIER func() antlr.TerminalNode

+ INTEGER func() antlr.TerminalNode

+ IsConst_valueContext func()

+ KW_FALSE func() antlr.TerminalNode

+ KW_TRUE func() antlr.TerminalNode

+ STRING func() antlr.TerminalNode

+ type IContainer_typeContext interface

+ GetParser func() antlr.Parser

+ IsContainer_typeContext func()

+ List_type func() IList_typeContext

+ Map_type func() IMap_typeContext

+ type IDefinitionContext interface

+ Const_def func() IConst_defContext

+ Enum_def func() IEnum_defContext

+ GetParser func() antlr.Parser

+ IsDefinitionContext func()

+ Rpc_def func() IRpc_defContext

+ Type_def func() IType_defContext

+ type IDocumentContext interface

+ AllDefinition func() []IDefinitionContext

+ Definition func(i int) IDefinitionContext

+ EOF func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsDocumentContext func()

+ type IEmbed_type_fieldContext interface

+ GetParser func() antlr.Parser

+ IsEmbed_type_fieldContext func()

+ User_type func() IUser_typeContext

+ type IEnum_defContext interface

+ AllEnum_field func() []IEnum_fieldContext

+ Enum_field func(i int) IEnum_fieldContext

+ GetParser func() antlr.Parser

+ IDENTIFIER func() antlr.TerminalNode

+ IsEnum_defContext func()

+ KW_ENUM func() antlr.TerminalNode

+ LEFT_BRACE func() antlr.TerminalNode

+ RIGHT_BRACE func() antlr.TerminalNode

+ type IEnum_fieldContext interface

+ EQUAL func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IDENTIFIER func() antlr.TerminalNode

+ INTEGER func() antlr.TerminalNode

+ IsEnum_fieldContext func()

+ type IGeneric_typeContext interface

+ Base_type func() IBase_typeContext

+ Container_type func() IContainer_typeContext

+ GetParser func() antlr.Parser

+ IsGeneric_typeContext func()

+ User_type func() IUser_typeContext

+ type IKey_typeContext interface

+ GetParser func() antlr.Parser

+ IsKey_typeContext func()

+ TYPE_INT func() antlr.TerminalNode

+ TYPE_STRING func() antlr.TerminalNode

+ type IList_typeContext interface

+ GREATER_THAN func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsList_typeContext func()

+ LESS_THAN func() antlr.TerminalNode

+ TYPE_LIST func() antlr.TerminalNode

+ Value_type func() IValue_typeContext

+ type IMap_typeContext interface

+ COMMA func() antlr.TerminalNode

+ GREATER_THAN func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsMap_typeContext func()

+ Key_type func() IKey_typeContext

+ LESS_THAN func() antlr.TerminalNode

+ TYPE_MAP func() antlr.TerminalNode

+ Value_type func() IValue_typeContext

+ type IRpc_annotationsContext interface

+ AllAnnotation func() []IAnnotationContext

+ Annotation func(i int) IAnnotationContext

+ GetParser func() antlr.Parser

+ IsRpc_annotationsContext func()

+ LEFT_BRACE func() antlr.TerminalNode

+ RIGHT_BRACE func() antlr.TerminalNode

+ type IRpc_defContext interface

+ GetParser func() antlr.Parser

+ IDENTIFIER func() antlr.TerminalNode

+ IsRpc_defContext func()

+ KW_RPC func() antlr.TerminalNode

+ LEFT_PAREN func() antlr.TerminalNode

+ RIGHT_PAREN func() antlr.TerminalNode

+ Rpc_annotations func() IRpc_annotationsContext

+ Rpc_req func() IRpc_reqContext

+ Rpc_resp func() IRpc_respContext

+ type IRpc_reqContext interface

+ GetParser func() antlr.Parser

+ IDENTIFIER func() antlr.TerminalNode

+ IsRpc_reqContext func()

+ type IRpc_respContext interface

+ GREATER_THAN func() antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IDENTIFIER func() antlr.TerminalNode

+ IsRpc_respContext func()

+ LESS_THAN func() antlr.TerminalNode

+ TYPE_STREAM func() antlr.TerminalNode

+ User_type func() IUser_typeContext

+ type IType_annotationsContext interface

+ AllAnnotation func() []IAnnotationContext

+ AllCOMMA func() []antlr.TerminalNode

+ Annotation func(i int) IAnnotationContext

+ COMMA func(i int) antlr.TerminalNode

+ GetParser func() antlr.Parser

+ IsType_annotationsContext func()

+ LEFT_PAREN func() antlr.TerminalNode

+ RIGHT_PAREN func() antlr.TerminalNode

+ type IType_defContext interface

+ AllIDENTIFIER func() []antlr.TerminalNode

+ AllType_field func() []IType_fieldContext

+ GREATER_THAN func() antlr.TerminalNode

+ Generic_type func() IGeneric_typeContext

+ GetParser func() antlr.Parser

+ IDENTIFIER func(i int) antlr.TerminalNode

+ IsType_defContext func()

+ KW_TYPE func() antlr.TerminalNode

+ LEFT_BRACE func() antlr.TerminalNode

+ LESS_THAN func() antlr.TerminalNode

+ RIGHT_BRACE func() antlr.TerminalNode

+ Type_field func(i int) IType_fieldContext

+ type IType_fieldContext interface

+ Common_type_field func() ICommon_type_fieldContext

+ Embed_type_field func() IEmbed_type_fieldContext

+ GetParser func() antlr.Parser

+ IsType_fieldContext func()

+ type IUser_typeContext interface

+ GetParser func() antlr.Parser

+ IDENTIFIER func() antlr.TerminalNode

+ IsUser_typeContext func()

+ QUESTION func() antlr.TerminalNode

+ type IValue_typeContext interface

+ Base_type func() IBase_typeContext

+ Container_type func() IContainer_typeContext

+ GetParser func() antlr.Parser

+ IsValue_typeContext func()

+ User_type func() IUser_typeContext

+ type Key_typeContext struct

+ func NewEmptyKey_typeContext() *Key_typeContext

+ func NewKey_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Key_typeContext

+ func (*Key_typeContext) IsKey_typeContext()

+ func (s *Key_typeContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Key_typeContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Key_typeContext) GetParser() antlr.Parser

+ func (s *Key_typeContext) GetRuleContext() antlr.RuleContext

+ func (s *Key_typeContext) TYPE_INT() antlr.TerminalNode

+ func (s *Key_typeContext) TYPE_STRING() antlr.TerminalNode

+ func (s *Key_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type ListType struct

+ Item TypeDefinition

+ func (t ListType) Text() string

+ type List_typeContext struct

+ func NewEmptyList_typeContext() *List_typeContext

+ func NewList_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *List_typeContext

+ func (*List_typeContext) IsList_typeContext()

+ func (s *List_typeContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *List_typeContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *List_typeContext) GREATER_THAN() antlr.TerminalNode

+ func (s *List_typeContext) GetParser() antlr.Parser

+ func (s *List_typeContext) GetRuleContext() antlr.RuleContext

+ func (s *List_typeContext) LESS_THAN() antlr.TerminalNode

+ func (s *List_typeContext) TYPE_LIST() antlr.TerminalNode

+ func (s *List_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *List_typeContext) Value_type() IValue_typeContext

+ type MapType struct

+ Key string

+ Value TypeDefinition

+ func (t MapType) Text() string

+ type Map_typeContext struct

+ func NewEmptyMap_typeContext() *Map_typeContext

+ func NewMap_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Map_typeContext

+ func (*Map_typeContext) IsMap_typeContext()

+ func (s *Map_typeContext) COMMA() antlr.TerminalNode

+ func (s *Map_typeContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Map_typeContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Map_typeContext) GREATER_THAN() antlr.TerminalNode

+ func (s *Map_typeContext) GetParser() antlr.Parser

+ func (s *Map_typeContext) GetRuleContext() antlr.RuleContext

+ func (s *Map_typeContext) Key_type() IKey_typeContext

+ func (s *Map_typeContext) LESS_THAN() antlr.TerminalNode

+ func (s *Map_typeContext) TYPE_MAP() antlr.TerminalNode

+ func (s *Map_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Map_typeContext) Value_type() IValue_typeContext

+ type MetaInfo struct

+ Config map[string]any

+ Name string

+ Version string

+ func ParseMeta(s string) (*MetaInfo, error)

+ type ParseTreeListener struct

+ Attached map[int]struct{}

+ Document Document

+ Tokens *antlr.CommonTokenStream

+ func (l *ParseTreeListener) ExitConst_def(ctx *Const_defContext)

+ func (l *ParseTreeListener) ExitEnum_def(ctx *Enum_defContext)

+ func (l *ParseTreeListener) ExitRpc_def(ctx *Rpc_defContext)

+ func (l *ParseTreeListener) ExitType_def(ctx *Type_defContext)

+ type Position struct

+ Start int

+ Stop int

+ type RPC struct

+ Annotations []Annotation

+ Comments Comments

+ Name string

+ Position Position

+ Request string

+ Response RespType

+ type RedefinedType struct

+ GenericType TypeDefinition

+ Name string

+ func (t RedefinedType) Text() string

+ type RespType struct

+ Stream bool

+ TypeName string

+ UserType *UserType

+ func (t RespType) Text() string

+ type Rpc_annotationsContext struct

+ func NewEmptyRpc_annotationsContext() *Rpc_annotationsContext

+ func NewRpc_annotationsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Rpc_annotationsContext

+ func (*Rpc_annotationsContext) IsRpc_annotationsContext()

+ func (s *Rpc_annotationsContext) AllAnnotation() []IAnnotationContext

+ func (s *Rpc_annotationsContext) Annotation(i int) IAnnotationContext

+ func (s *Rpc_annotationsContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Rpc_annotationsContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Rpc_annotationsContext) GetParser() antlr.Parser

+ func (s *Rpc_annotationsContext) GetRuleContext() antlr.RuleContext

+ func (s *Rpc_annotationsContext) LEFT_BRACE() antlr.TerminalNode

+ func (s *Rpc_annotationsContext) RIGHT_BRACE() antlr.TerminalNode

+ func (s *Rpc_annotationsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Rpc_defContext struct

+ func NewEmptyRpc_defContext() *Rpc_defContext

+ func NewRpc_defContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Rpc_defContext

+ func (*Rpc_defContext) IsRpc_defContext()

+ func (s *Rpc_defContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Rpc_defContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Rpc_defContext) GetParser() antlr.Parser

+ func (s *Rpc_defContext) GetRuleContext() antlr.RuleContext

+ func (s *Rpc_defContext) IDENTIFIER() antlr.TerminalNode

+ func (s *Rpc_defContext) KW_RPC() antlr.TerminalNode

+ func (s *Rpc_defContext) LEFT_PAREN() antlr.TerminalNode

+ func (s *Rpc_defContext) RIGHT_PAREN() antlr.TerminalNode

+ func (s *Rpc_defContext) Rpc_annotations() IRpc_annotationsContext

+ func (s *Rpc_defContext) Rpc_req() IRpc_reqContext

+ func (s *Rpc_defContext) Rpc_resp() IRpc_respContext

+ func (s *Rpc_defContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Rpc_reqContext struct

+ func NewEmptyRpc_reqContext() *Rpc_reqContext

+ func NewRpc_reqContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Rpc_reqContext

+ func (*Rpc_reqContext) IsRpc_reqContext()

+ func (s *Rpc_reqContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Rpc_reqContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Rpc_reqContext) GetParser() antlr.Parser

+ func (s *Rpc_reqContext) GetRuleContext() antlr.RuleContext

+ func (s *Rpc_reqContext) IDENTIFIER() antlr.TerminalNode

+ func (s *Rpc_reqContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Rpc_respContext struct

+ func NewEmptyRpc_respContext() *Rpc_respContext

+ func NewRpc_respContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Rpc_respContext

+ func (*Rpc_respContext) IsRpc_respContext()

+ func (s *Rpc_respContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Rpc_respContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Rpc_respContext) GREATER_THAN() antlr.TerminalNode

+ func (s *Rpc_respContext) GetParser() antlr.Parser

+ func (s *Rpc_respContext) GetRuleContext() antlr.RuleContext

+ func (s *Rpc_respContext) IDENTIFIER() antlr.TerminalNode

+ func (s *Rpc_respContext) LESS_THAN() antlr.TerminalNode

+ func (s *Rpc_respContext) TYPE_STREAM() antlr.TerminalNode

+ func (s *Rpc_respContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Rpc_respContext) User_type() IUser_typeContext

+ type TLexer struct

+ func NewTLexer(input antlr.CharStream) *TLexer

+ type TParser struct

+ func NewTParser(input antlr.TokenStream) *TParser

+ func (p *TParser) Annotation() (localctx IAnnotationContext)

+ func (p *TParser) Base_type() (localctx IBase_typeContext)

+ func (p *TParser) Common_field_type() (localctx ICommon_field_typeContext)

+ func (p *TParser) Common_type_field() (localctx ICommon_type_fieldContext)

+ func (p *TParser) Const_def() (localctx IConst_defContext)

+ func (p *TParser) Const_type() (localctx IConst_typeContext)

+ func (p *TParser) Const_value() (localctx IConst_valueContext)

+ func (p *TParser) Container_type() (localctx IContainer_typeContext)

+ func (p *TParser) Definition() (localctx IDefinitionContext)

+ func (p *TParser) Document() (localctx IDocumentContext)

+ func (p *TParser) Embed_type_field() (localctx IEmbed_type_fieldContext)

+ func (p *TParser) Enum_def() (localctx IEnum_defContext)

+ func (p *TParser) Enum_field() (localctx IEnum_fieldContext)

+ func (p *TParser) Generic_type() (localctx IGeneric_typeContext)

+ func (p *TParser) Key_type() (localctx IKey_typeContext)

+ func (p *TParser) List_type() (localctx IList_typeContext)

+ func (p *TParser) Map_type() (localctx IMap_typeContext)

+ func (p *TParser) Rpc_annotations() (localctx IRpc_annotationsContext)

+ func (p *TParser) Rpc_def() (localctx IRpc_defContext)

+ func (p *TParser) Rpc_req() (localctx IRpc_reqContext)

+ func (p *TParser) Rpc_resp() (localctx IRpc_respContext)

+ func (p *TParser) Type_annotations() (localctx IType_annotationsContext)

+ func (p *TParser) Type_def() (localctx IType_defContext)

+ func (p *TParser) Type_field() (localctx IType_fieldContext)

+ func (p *TParser) User_type() (localctx IUser_typeContext)

+ func (p *TParser) Value_type() (localctx IValue_typeContext)

+ type TParserListener interface

+ EnterAnnotation func(c *AnnotationContext)

+ EnterBase_type func(c *Base_typeContext)

+ EnterCommon_field_type func(c *Common_field_typeContext)

+ EnterCommon_type_field func(c *Common_type_fieldContext)

+ EnterConst_def func(c *Const_defContext)

+ EnterConst_type func(c *Const_typeContext)

+ EnterConst_value func(c *Const_valueContext)

+ EnterContainer_type func(c *Container_typeContext)

+ EnterDefinition func(c *DefinitionContext)

+ EnterDocument func(c *DocumentContext)

+ EnterEmbed_type_field func(c *Embed_type_fieldContext)

+ EnterEnum_def func(c *Enum_defContext)

+ EnterEnum_field func(c *Enum_fieldContext)

+ EnterGeneric_type func(c *Generic_typeContext)

+ EnterKey_type func(c *Key_typeContext)

+ EnterList_type func(c *List_typeContext)

+ EnterMap_type func(c *Map_typeContext)

+ EnterRpc_annotations func(c *Rpc_annotationsContext)

+ EnterRpc_def func(c *Rpc_defContext)

+ EnterRpc_req func(c *Rpc_reqContext)

+ EnterRpc_resp func(c *Rpc_respContext)

+ EnterType_annotations func(c *Type_annotationsContext)

+ EnterType_def func(c *Type_defContext)

+ EnterType_field func(c *Type_fieldContext)

+ EnterUser_type func(c *User_typeContext)

+ EnterValue_type func(c *Value_typeContext)

+ ExitAnnotation func(c *AnnotationContext)

+ ExitBase_type func(c *Base_typeContext)

+ ExitCommon_field_type func(c *Common_field_typeContext)

+ ExitCommon_type_field func(c *Common_type_fieldContext)

+ ExitConst_def func(c *Const_defContext)

+ ExitConst_type func(c *Const_typeContext)

+ ExitConst_value func(c *Const_valueContext)

+ ExitContainer_type func(c *Container_typeContext)

+ ExitDefinition func(c *DefinitionContext)

+ ExitDocument func(c *DocumentContext)

+ ExitEmbed_type_field func(c *Embed_type_fieldContext)

+ ExitEnum_def func(c *Enum_defContext)

+ ExitEnum_field func(c *Enum_fieldContext)

+ ExitGeneric_type func(c *Generic_typeContext)

+ ExitKey_type func(c *Key_typeContext)

+ ExitList_type func(c *List_typeContext)

+ ExitMap_type func(c *Map_typeContext)

+ ExitRpc_annotations func(c *Rpc_annotationsContext)

+ ExitRpc_def func(c *Rpc_defContext)

+ ExitRpc_req func(c *Rpc_reqContext)

+ ExitRpc_resp func(c *Rpc_respContext)

+ ExitType_annotations func(c *Type_annotationsContext)

+ ExitType_def func(c *Type_defContext)

+ ExitType_field func(c *Type_fieldContext)

+ ExitUser_type func(c *User_typeContext)

+ ExitValue_type func(c *Value_typeContext)

+ type Type struct

+ Comments Comments

+ Fields []TypeField

+ GenericName *string

+ Name string

+ Position Position

+ Redefined *RedefinedType

+ type TypeDefinition interface

+ Text func() string

+ type TypeField struct

+ Annotations []Annotation

+ Comments Comments

+ Default *string

+ FieldType TypeDefinition

+ Name string

+ Position Position

+ type Type_annotationsContext struct

+ func NewEmptyType_annotationsContext() *Type_annotationsContext

+ func NewType_annotationsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Type_annotationsContext

+ func (*Type_annotationsContext) IsType_annotationsContext()

+ func (s *Type_annotationsContext) AllAnnotation() []IAnnotationContext

+ func (s *Type_annotationsContext) AllCOMMA() []antlr.TerminalNode

+ func (s *Type_annotationsContext) Annotation(i int) IAnnotationContext

+ func (s *Type_annotationsContext) COMMA(i int) antlr.TerminalNode

+ func (s *Type_annotationsContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Type_annotationsContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Type_annotationsContext) GetParser() antlr.Parser

+ func (s *Type_annotationsContext) GetRuleContext() antlr.RuleContext

+ func (s *Type_annotationsContext) LEFT_PAREN() antlr.TerminalNode

+ func (s *Type_annotationsContext) RIGHT_PAREN() antlr.TerminalNode

+ func (s *Type_annotationsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Type_defContext struct

+ func NewEmptyType_defContext() *Type_defContext

+ func NewType_defContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Type_defContext

+ func (*Type_defContext) IsType_defContext()

+ func (s *Type_defContext) AllIDENTIFIER() []antlr.TerminalNode

+ func (s *Type_defContext) AllType_field() []IType_fieldContext

+ func (s *Type_defContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Type_defContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Type_defContext) GREATER_THAN() antlr.TerminalNode

+ func (s *Type_defContext) Generic_type() IGeneric_typeContext

+ func (s *Type_defContext) GetParser() antlr.Parser

+ func (s *Type_defContext) GetRuleContext() antlr.RuleContext

+ func (s *Type_defContext) IDENTIFIER(i int) antlr.TerminalNode

+ func (s *Type_defContext) KW_TYPE() antlr.TerminalNode

+ func (s *Type_defContext) LEFT_BRACE() antlr.TerminalNode

+ func (s *Type_defContext) LESS_THAN() antlr.TerminalNode

+ func (s *Type_defContext) RIGHT_BRACE() antlr.TerminalNode

+ func (s *Type_defContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Type_defContext) Type_field(i int) IType_fieldContext

+ type Type_fieldContext struct

+ func NewEmptyType_fieldContext() *Type_fieldContext

+ func NewType_fieldContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Type_fieldContext

+ func (*Type_fieldContext) IsType_fieldContext()

+ func (s *Type_fieldContext) Common_type_field() ICommon_type_fieldContext

+ func (s *Type_fieldContext) Embed_type_field() IEmbed_type_fieldContext

+ func (s *Type_fieldContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Type_fieldContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Type_fieldContext) GetParser() antlr.Parser

+ func (s *Type_fieldContext) GetRuleContext() antlr.RuleContext

+ func (s *Type_fieldContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type UserType struct

+ Name string

+ Optional bool

+ func (t UserType) Text() string

+ type User_typeContext struct

+ func NewEmptyUser_typeContext() *User_typeContext

+ func NewUser_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *User_typeContext

+ func (*User_typeContext) IsUser_typeContext()

+ func (s *User_typeContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *User_typeContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *User_typeContext) GetParser() antlr.Parser

+ func (s *User_typeContext) GetRuleContext() antlr.RuleContext

+ func (s *User_typeContext) IDENTIFIER() antlr.TerminalNode

+ func (s *User_typeContext) QUESTION() antlr.TerminalNode

+ func (s *User_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ type Value_typeContext struct

+ func NewEmptyValue_typeContext() *Value_typeContext

+ func NewValue_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Value_typeContext

+ func (*Value_typeContext) IsValue_typeContext()

+ func (s *Value_typeContext) Base_type() IBase_typeContext

+ func (s *Value_typeContext) Container_type() IContainer_typeContext

+ func (s *Value_typeContext) EnterRule(listener antlr.ParseTreeListener)

+ func (s *Value_typeContext) ExitRule(listener antlr.ParseTreeListener)

+ func (s *Value_typeContext) GetParser() antlr.Parser

+ func (s *Value_typeContext) GetRuleContext() antlr.RuleContext

+ func (s *Value_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string

+ func (s *Value_typeContext) User_type() IUser_typeContext

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL