idl

type AnnotationCollection ¶

type AnnotationCollection []AnnotationValue

AnnotationCollection represents a list of Annotation values.

func (a AnnotationCollection) FindByName(name string) (*AnnotationValue, bool)

type AnnotationValue ¶

type AnnotationValue struct {
	Offset Offset
	Name   string
	Value  []string
}

AnnotationValue represents a single @annotation value present in a source file.

type Array ¶

type Array struct {
	Of Type
}

func (Array) Type() TypeType

type Element ¶

type Element int

Element represents a single Token element kind in a source file

const (
	InvalidElement Element = iota
	Identifier             // [a-z][0-9a-z_]
	OpenCurly              // {
	CloseCurly             // }
	OpenParen              // (
	CloseParen             // )
	OpenAngled             // <
	CloseAngled            // >
	Comma                  // ,
	Dot                    // .
	LineBreak              // \n
	Equal                  // =
	Number                 // 0-9+
	Arrow                  // ->
	Semi                   // ;
	Comment                // Anything from # onwards
	Annotation             // Anything from @ until next space
	StringElement          // Anything between "
	EOF
)

func (i Element) String() string

type Field ¶

type Field struct {
	Offset      Offset
	Name        string
	Comments    []string
	Annotations AnnotationCollection
	Type        Type
	Index       int
}

Field represents a Message's field

type File ¶

type File struct {
	// Tree contains a list of Package, Import, Message, and Service objects
	// representing structures defined in a source file.
	Tree []any

	// Package represents the package name defined by the source file.
	Package string

	// DeclaredMessages contains the names of all messages declared by the
	// source file.
	DeclaredMessages []string

	// DeclaredService contains the names of all services declared by the
	// source file.
	DeclaredServices []string

	// ImportedFiles contains a list of paths provided to `import` directives.
	ImportedFiles []string
	// contains filtered or unexported fields
}

File represents a single YARP source file.

func Parse(tokens []Token) (*File, error)

func (f File) MessageByName(name string) (*Message, bool)

func (f File) ServiceByName(name string) (*Service, bool)

type FileSet ¶

type FileSet struct {
	Messages []*Message
	Services []*Service
	// contains filtered or unexported fields
}

FileSet represents structures provided by a set of source files.

func NewFileSet() *FileSet

func (f *FileSet) FindMessage(name string) (*Message, bool)

func (f FileSet) FromSamePackage(name string) bool

func (f *FileSet) Load(path string) error

func (f FileSet) Package() string

type Import ¶

type Import struct {
	Offset Offset
	Path   string
}

Import represents a `import` statement, which includes a path to be loaded.

type ImportFileNotFoundError ¶

type ImportFileNotFoundError struct{ Source, Path string }

ImportFileNotFoundError indicates that a file imported by a given source could not be found.

func (i ImportFileNotFoundError) Error() string

type Map ¶

type Map struct {
	Key   PrimitiveType
	Value Type
}

func (Map) Type() TypeType

type Message ¶

type Message struct {
	Offset      Offset
	Name        string
	Comments    []string
	Annotations AnnotationCollection
	Fields      []any
}

Message represents a single `message` declared in a source file.

type Method ¶

type Method struct {
	Offset          Offset
	Name            string
	Comments        []string
	Annotations     AnnotationCollection
	ArgumentType    string
	ReturnType      string
	ReturnStreaming bool
}

Method represents a Service's method

type MixedPackagesError ¶

type MixedPackagesError struct{ Path, Package1, Package2 string }

MixedPackagesError indicates that source files provides different packages. Only a single package can be compiled at a time.

func (m MixedPackagesError) Error() string

type Offset ¶

type Offset struct {
	StartsAt Position
	EndsAt   Position
}

Offset represents the offset in which a given structure appears in the source file. It includes Position for both the point in which it starts, and the point in which it ends.

type OneOfField ¶

type OneOfField struct {
	Offset      Offset
	Comments    []string
	Annotations AnnotationCollection
	Index       int
	Items       []any
}

OneOfField represents an oneof field present in a Message

type Package ¶

type Package struct {
	Offset Offset
	Name   string
}

Package represents a `package` declaration in a source file.

type ParseError ¶

type ParseError struct {
	Token   Token
	Message string
}

ParseError indicates that one or more productions from the scanner does not define a valid IDL file.

func (p ParseError) Error() string

type Position ¶

type Position struct {
	Line   int
	Column int
}

Position represents a given Line/Column position within a source file.

type Primitive ¶

type Primitive struct {
	Kind PrimitiveType
}

func (Primitive) Type() TypeType

type PrimitiveType ¶

type PrimitiveType int

PrimitiveType represents a single type recognized by YARP

const (
	Invalid PrimitiveType = iota
	Uint8
	Uint16
	Uint32
	Uint64
	Int8
	Int16
	Int32
	Int64
	Float32
	Float64
	Struct
	OneOf
	Bool
	String
)

func (i PrimitiveType) String() string

type Scanner ¶

type Scanner struct {
	// contains filtered or unexported fields
}

Scanner implements mechanisms responsible for reading an IDL file into a list of tokens.

func NewScanner(r io.Reader) (*Scanner, error)

func (s *Scanner) Run() ([]Token, error)

type Service ¶

type Service struct {
	Offset      Offset
	Name        string
	Comments    []string
	Annotations AnnotationCollection
	Methods     []Method
}

Service represents a single `service` declared in a source file.

type SourceFileNotFoundError ¶

type SourceFileNotFoundError struct{ Path string }

SourceFileNotFoundError indicates that the process could not find an input file provided by the user.

func (s SourceFileNotFoundError) Error() string

type SourceIsDirectoryError ¶

type SourceIsDirectoryError struct{ Path string }

SourceIsDirectoryError indicates that a given source file is, in fact, a directory, and therefore cannot be read.

func (s SourceIsDirectoryError) Error() string

type SyntaxError ¶

type SyntaxError struct {
	Message string
	Line    int
	Column  int
}

SyntaxError indicates that a provided file does not contain a valid YARP Interface Description File.

func (s SyntaxError) Error() string

type Token ¶

type Token struct {
	Type   Element
	Value  string
	Line   int
	Column int
}

Token represents a single token present in a source file

func Scan(r io.Reader) ([]Token, error)

func (t Token) String() string

type Type ¶

type Type interface {
	Type() TypeType
}

type TypeType ¶

type TypeType int

TypeType represents the concrete type of a Field.

const (
	TypeInvalid TypeType = iota
	TypePrimitive
	TypeArray
	TypeMap
	TypeUnresolved
)

type Unresolved ¶

type Unresolved struct {
	Name string
}

func (Unresolved) Type() TypeType