binary

package
v0.0.0-...-6a25f69 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 23, 2020 License: MIT, MIT Imports: 4 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type BitwiseAnd 

type BitwiseAnd struct {
	FreeFloating freefloating.Collection
	Position     *position.Position
	Left         node.Node
	Right        node.Node
}

BitwiseAnd node

func NewBitwiseAnd 

func NewBitwiseAnd(Variable node.Node, Expression node.Node) *BitwiseAnd

NewBitwiseAnd node constructor

func (*BitwiseAnd) Attributes 

func (n *BitwiseAnd) Attributes() map[string]interface{}

Attributes returns node attributes as map

func (*BitwiseAnd) GetFreeFloating 

func (n *BitwiseAnd) GetFreeFloating() *freefloating.Collection

func (*BitwiseAnd) GetPosition 

func (n *BitwiseAnd) GetPosition() *position.Position

GetPosition returns node positions

func (*BitwiseAnd) SetPosition 

func (n *BitwiseAnd) SetPosition(p *position.Position)

SetPosition sets node position

func (*BitwiseAnd) Walk 

func (n *BitwiseAnd) Walk(v walker.Visitor)

Walk traverses nodes Walk is invoked recursively until v.EnterNode returns true

type BitwiseOr 

type BitwiseOr struct {
	FreeFloating freefloating.Collection
	Position     *position.Position
	Left         node.Node
	Right        node.Node
}

BitwiseOr node

func NewBitwiseOr 

func NewBitwiseOr(Variable node.Node, Expression node.Node) *BitwiseOr

NewBitwiseOr node constructor

func (*BitwiseOr) Attributes 

func (n *BitwiseOr) Attributes() map[string]interface{}

Attributes returns node attributes as map

func (*BitwiseOr) GetFreeFloating 

func (n *BitwiseOr) GetFreeFloating() *freefloating.Collection

func (*BitwiseOr) GetPosition 

func (n *BitwiseOr) GetPosition() *position.Position

GetPosition returns node positions

func (*BitwiseOr) SetPosition 

func (n *BitwiseOr) SetPosition(p *position.Position)

SetPosition sets node position

func (*BitwiseOr) Walk 

func (n *BitwiseOr) Walk(v walker.Visitor)

Walk traverses nodes Walk is invoked recursively until v.EnterNode returns true

type BitwiseXor 

type BitwiseXor struct {
	FreeFloating freefloating.Collection
	Position     *position.Position
	Left         node.Node
	Right        node.Node
}

BitwiseXor node

func NewBitwiseXor 

func NewBitwiseXor(Variable node.Node, Expression node.Node) *BitwiseXor

NewBitwiseXor node constructor

func (*BitwiseXor) Attributes 

func (n *BitwiseXor) Attributes() map[string]interface{}

Attributes returns node attributes as map

func (*BitwiseXor) GetFreeFloating 

func (n *BitwiseXor) GetFreeFloating() *freefloating.Collection

func (*BitwiseXor) GetPosition 

func (n *BitwiseXor) GetPosition() *position.Position

GetPosition returns node positions

func (*BitwiseXor) SetPosition 

func (n *BitwiseXor) SetPosition(p *position.Position)

SetPosition sets node position

func (*BitwiseXor) Walk 

func (n *BitwiseXor) Walk(v walker.Visitor)

Walk traverses nodes Walk is invoked recursively until v.EnterNode returns true

type BooleanAnd 

type BooleanAnd struct {
	FreeFloating freefloating.Collection
	Position     *position.Position
	Left         node.Node
	Right        node.Node
}

BooleanAnd node

func NewBooleanAnd 

func NewBooleanAnd(Variable node.Node, Expression node.Node) *BooleanAnd

NewBooleanAnd node constructor

func (*BooleanAnd) Attributes 

func (n *BooleanAnd) Attributes() map[string]interface{}

Attributes returns node attributes as map

func (*BooleanAnd) GetFreeFloating 

func (n *BooleanAnd) GetFreeFloating() *freefloating.Collection

func (*BooleanAnd) GetPosition 

func (n *BooleanAnd) GetPosition() *position.Position

GetPosition returns node positions

func (*BooleanAnd) SetPosition 

func (n *BooleanAnd) SetPosition(p *position.Position)

SetPosition sets node position

func (*BooleanAnd) Walk 

func (n *BooleanAnd) Walk(v walker.Visitor)

Walk traverses nodes Walk is invoked recursively until v.EnterNode returns true

type BooleanOr 

type BooleanOr struct {
	FreeFloating freefloating.Collection
	Position     *position.Position
	Left         node.Node
	Right        node.Node
}

BooleanOr node

func NewBooleanOr 

func NewBooleanOr(Variable node.Node, Expression node.Node) *BooleanOr

NewBooleanOr node constructor

func (*BooleanOr) Attributes 

func (n *BooleanOr) Attributes() map[string]interface{}

Attributes returns node attributes as map

func (*BooleanOr) GetFreeFloating 

func (n *BooleanOr) GetFreeFloating() *freefloating.Collection

func (*BooleanOr) GetPosition 

func (n *BooleanOr) GetPosition() *position.Position

GetPosition returns node positions

func (*BooleanOr) SetPosition 

func (n *BooleanOr) SetPosition(p *position.Position)

SetPosition sets node position

func (*BooleanOr) Walk 

func (n *BooleanOr) Walk(v walker.Visitor)

Walk traverses nodes Walk is invoked recursively until v.EnterNode returns true

type Coalesce 

type Coalesce struct {
	FreeFloating freefloating.Collection
	Position     *position.Position
	Left         node.Node
	Right        node.Node
}

Coalesce node

func NewCoalesce 

func NewCoalesce(Variable node.Node, Expression node.Node) *Coalesce

NewCoalesce node constructor

func (*Coalesce) Attributes 

func (n *Coalesce) Attributes() map[string]interface{}

Attributes returns node attributes as map

func (*Coalesce) GetFreeFloating 

func (n *Coalesce) GetFreeFloating() *freefloating.Collection

func (*Coalesce) GetPosition 

func (n *Coalesce) GetPosition() *position.Position

GetPosition returns node positions

func (*Coalesce) SetPosition 

func (n *Coalesce) SetPosition(p *position.Position)

SetPosition sets node position

func (*Coalesce) Walk 

func (n *Coalesce) Walk(v walker.Visitor)

Walk traverses nodes Walk is invoked recursively until v.EnterNode returns true

type Concat 

type Concat struct {
	FreeFloating freefloating.Collection
	Position     *position.Position
	Left         node.Node
	Right        node.Node
}

Concat node

func NewConcat 

func NewConcat(Variable node.Node, Expression node.Node) *Concat

NewConcat node constructor

func (*Concat) Attributes 

func (n *Concat) Attributes() map[string]interface{}

Attributes returns node attributes as map

func (*Concat) GetFreeFloating 

func (n *Concat) GetFreeFloating() *freefloating.Collection

func (*Concat) GetPosition 

func (n *Concat) GetPosition() *position.Position

GetPosition returns node positions

func (*Concat) SetPosition 

func (n *Concat) SetPosition(p *position.Position)

SetPosition sets node position

func (*Concat) Walk 

func (n *Concat) Walk(v walker.Visitor)

Walk traverses nodes Walk is invoked recursively until v.EnterNode returns true

type Div 

type Div struct {
	FreeFloating freefloating.Collection
	Position     *position.Position
	Left         node.Node
	Right        node.Node
}

Div node

func NewDiv 

func NewDiv(Variable node.Node, Expression node.Node) *Div

NewDiv node constructor

func (*Div) Attributes 

func (n *Div) Attributes() map[string]interface{}

Attributes returns node attributes as map

func (*Div) GetFreeFloating 

func (n *Div) GetFreeFloating() *freefloating.Collection

func (*Div) GetPosition 

func (n *Div) GetPosition() *position.Position

GetPosition returns node positions

func (*Div) SetPosition 

func (n *Div) SetPosition(p *position.Position)

SetPosition sets node position

func (*Div) Walk 

func (n *Div) Walk(v walker.Visitor)

Walk traverses nodes Walk is invoked recursively until v.EnterNode returns true

type Equal 

type Equal struct {
	FreeFloating freefloating.Collection
	Position     *position.Position
	Left         node.Node
	Right        node.Node
}

Equal node

func NewEqual 

func NewEqual(Variable node.Node, Expression node.Node) *Equal

NewEqual node constructor

func (*Equal) Attributes 

func (n *Equal) Attributes() map[string]interface{}

Attributes returns node attributes as map

func (*Equal) GetFreeFloating 

func (n *Equal) GetFreeFloating() *freefloating.Collection

func (*Equal) GetPosition 

func (n *Equal) GetPosition() *position.Position

GetPosition returns node positions

func (*Equal) SetPosition 

func (n *Equal) SetPosition(p *position.Position)

SetPosition sets node position

func (*Equal) Walk 

func (n *Equal) Walk(v walker.Visitor)

Walk traverses nodes Walk is invoked recursively until v.EnterNode returns true

type Greater 

type Greater struct {
	FreeFloating freefloating.Collection
	Position     *position.Position
	Left         node.Node
	Right        node.Node
}

Greater node

func NewGreater 

func NewGreater(Variable node.Node, Expression node.Node) *Greater

NewGreater node constructor

func (*Greater) Attributes 

func (n *Greater) Attributes() map[string]interface{}

Attributes returns node attributes as map

func (*Greater) GetFreeFloating 

func (n *Greater) GetFreeFloating() *freefloating.Collection

func (*Greater) GetPosition 

func (n *Greater) GetPosition() *position.Position

GetPosition returns node positions

func (*Greater) SetPosition 

func (n *Greater) SetPosition(p *position.Position)

SetPosition sets node position

func (*Greater) Walk 

func (n *Greater) Walk(v walker.Visitor)

Walk traverses nodes Walk is invoked recursively until v.EnterNode returns true

type GreaterOrEqual 

type GreaterOrEqual struct {
	FreeFloating freefloating.Collection
	Position     *position.Position
	Left         node.Node
	Right        node.Node
}

GreaterOrEqual node

func NewGreaterOrEqual 

func NewGreaterOrEqual(Variable node.Node, Expression node.Node) *GreaterOrEqual

NewGreaterOrEqual node constructor

func (*GreaterOrEqual) Attributes 

func (n *GreaterOrEqual) Attributes() map[string]interface{}

Attributes returns node attributes as map

func (*GreaterOrEqual) GetFreeFloating 

func (n *GreaterOrEqual) GetFreeFloating() *freefloating.Collection

func (*GreaterOrEqual) GetPosition 

func (n *GreaterOrEqual) GetPosition() *position.Position

GetPosition returns node positions

func (*GreaterOrEqual) SetPosition 

func (n *GreaterOrEqual) SetPosition(p *position.Position)

SetPosition sets node position

func (*GreaterOrEqual) Walk 

func (n *GreaterOrEqual) Walk(v walker.Visitor)

Walk traverses nodes Walk is invoked recursively until v.EnterNode returns true

type Identical 

type Identical struct {
	FreeFloating freefloating.Collection
	Position     *position.Position
	Left         node.Node
	Right        node.Node
}

Identical node

func NewIdentical 

func NewIdentical(Variable node.Node, Expression node.Node) *Identical

NewIdentical node constructor

func (*Identical) Attributes 

func (n *Identical) Attributes() map[string]interface{}

Attributes returns node attributes as map

func (*Identical) GetFreeFloating 

func (n *Identical) GetFreeFloating() *freefloating.Collection

func (*Identical) GetPosition 

func (n *Identical) GetPosition() *position.Position

GetPosition returns node positions

func (*Identical) SetPosition 

func (n *Identical) SetPosition(p *position.Position)

SetPosition sets node position

func (*Identical) Walk 

func (n *Identical) Walk(v walker.Visitor)

Walk traverses nodes Walk is invoked recursively until v.EnterNode returns true

type LogicalAnd 

type LogicalAnd struct {
	FreeFloating freefloating.Collection
	Position     *position.Position
	Left         node.Node
	Right        node.Node
}

LogicalAnd node

func NewLogicalAnd 

func NewLogicalAnd(Variable node.Node, Expression node.Node) *LogicalAnd

NewLogicalAnd node constructor

func (*LogicalAnd) Attributes 

func (n *LogicalAnd) Attributes() map[string]interface{}

Attributes returns node attributes as map

func (*LogicalAnd) GetFreeFloating 

func (n *LogicalAnd) GetFreeFloating() *freefloating.Collection

func (*LogicalAnd) GetPosition 

func (n *LogicalAnd) GetPosition() *position.Position

GetPosition returns node positions

func (*LogicalAnd) SetPosition 

func (n *LogicalAnd) SetPosition(p *position.Position)

SetPosition sets node position

func (*LogicalAnd) Walk 

func (n *LogicalAnd) Walk(v walker.Visitor)

Walk traverses nodes Walk is invoked recursively until v.EnterNode returns true

type LogicalOr 

type LogicalOr struct {
	FreeFloating freefloating.Collection
	Position     *position.Position
	Left         node.Node
	Right        node.Node
}

LogicalOr node

func NewLogicalOr 

func NewLogicalOr(Variable node.Node, Expression node.Node) *LogicalOr

NewLogicalOr node constructor

func (*LogicalOr) Attributes 

func (n *LogicalOr) Attributes() map[string]interface{}

Attributes returns node attributes as map

func (*LogicalOr) GetFreeFloating 

func (n *LogicalOr) GetFreeFloating() *freefloating.Collection

func (*LogicalOr) GetPosition 

func (n *LogicalOr) GetPosition() *position.Position

GetPosition returns node positions

func (*LogicalOr) SetPosition 

func (n *LogicalOr) SetPosition(p *position.Position)

SetPosition sets node position

func (*LogicalOr) Walk 

func (n *LogicalOr) Walk(v walker.Visitor)

Walk traverses nodes Walk is invoked recursively until v.EnterNode returns true

type LogicalXor 

type LogicalXor struct {
	FreeFloating freefloating.Collection
	Position     *position.Position
	Left         node.Node
	Right        node.Node
}

LogicalXor node

func NewLogicalXor 

func NewLogicalXor(Variable node.Node, Expression node.Node) *LogicalXor

NewLogicalXor node constructor

func (*LogicalXor) Attributes 

func (n *LogicalXor) Attributes() map[string]interface{}

Attributes returns node attributes as map

func (*LogicalXor) GetFreeFloating 

func (n *LogicalXor) GetFreeFloating() *freefloating.Collection

func (*LogicalXor) GetPosition 

func (n *LogicalXor) GetPosition() *position.Position

GetPosition returns node positions

func (*LogicalXor) SetPosition 

func (n *LogicalXor) SetPosition(p *position.Position)

SetPosition sets node position

func (*LogicalXor) Walk 

func (n *LogicalXor) Walk(v walker.Visitor)

Walk traverses nodes Walk is invoked recursively until v.EnterNode returns true

type Minus 

type Minus struct {
	FreeFloating freefloating.Collection
	Position     *position.Position
	Left         node.Node
	Right        node.Node
}

Minus node

func NewMinus 

func NewMinus(Variable node.Node, Expression node.Node) *Minus

NewMinus node constructor

func (*Minus) Attributes 

func (n *Minus) Attributes() map[string]interface{}

Attributes returns node attributes as map

func (*Minus) GetFreeFloating 

func (n *Minus) GetFreeFloating() *freefloating.Collection

func (*Minus) GetPosition 

func (n *Minus) GetPosition() *position.Position

GetPosition returns node positions

func (*Minus) SetPosition 

func (n *Minus) SetPosition(p *position.Position)

SetPosition sets node position

func (*Minus) Walk 

func (n *Minus) Walk(v walker.Visitor)

Walk traverses nodes Walk is invoked recursively until v.EnterNode returns true

type Mod 

type Mod struct {
	FreeFloating freefloating.Collection
	Position     *position.Position
	Left         node.Node
	Right        node.Node
}

Mod node

func NewMod 

func NewMod(Variable node.Node, Expression node.Node) *Mod

NewMod node constructor

func (*Mod) Attributes 

func (n *Mod) Attributes() map[string]interface{}

Attributes returns node attributes as map

func (*Mod) GetFreeFloating 

func (n *Mod) GetFreeFloating() *freefloating.Collection

func (*Mod) GetPosition 

func (n *Mod) GetPosition() *position.Position

GetPosition returns node positions

func (*Mod) SetPosition 

func (n *Mod) SetPosition(p *position.Position)

SetPosition sets node position

func (*Mod) Walk 

func (n *Mod) Walk(v walker.Visitor)

Walk traverses nodes Walk is invoked recursively until v.EnterNode returns true

type Mul 

type Mul struct {
	FreeFloating freefloating.Collection
	Position     *position.Position
	Left         node.Node
	Right        node.Node
}

Mul node

func NewMul 

func NewMul(Variable node.Node, Expression node.Node) *Mul

NewMul node constructor

func (*Mul) Attributes 

func (n *Mul) Attributes() map[string]interface{}

Attributes returns node attributes as map

func (*Mul) GetFreeFloating 

func (n *Mul) GetFreeFloating() *freefloating.Collection

func (*Mul) GetPosition 

func (n *Mul) GetPosition() *position.Position

GetPosition returns node positions

func (*Mul) SetPosition 

func (n *Mul) SetPosition(p *position.Position)

SetPosition sets node position

func (*Mul) Walk 

func (n *Mul) Walk(v walker.Visitor)

Walk traverses nodes Walk is invoked recursively until v.EnterNode returns true

type NotEqual 

type NotEqual struct {
	FreeFloating freefloating.Collection
	Position     *position.Position
	Left         node.Node
	Right        node.Node
}

NotEqual node

func NewNotEqual 

func NewNotEqual(Variable node.Node, Expression node.Node) *NotEqual

NewNotEqual node constructor

func (*NotEqual) Attributes 

func (n *NotEqual) Attributes() map[string]interface{}

Attributes returns node attributes as map

func (*NotEqual) GetFreeFloating 

func (n *NotEqual) GetFreeFloating() *freefloating.Collection

func (*NotEqual) GetPosition 

func (n *NotEqual) GetPosition() *position.Position

GetPosition returns node positions

func (*NotEqual) SetPosition 

func (n *NotEqual) SetPosition(p *position.Position)

SetPosition sets node position

func (*NotEqual) Walk 

func (n *NotEqual) Walk(v walker.Visitor)

Walk traverses nodes Walk is invoked recursively until v.EnterNode returns true

type NotIdentical 

type NotIdentical struct {
	FreeFloating freefloating.Collection
	Position     *position.Position
	Left         node.Node
	Right        node.Node
}

NotIdentical node

func NewNotIdentical 

func NewNotIdentical(Variable node.Node, Expression node.Node) *NotIdentical

NewNotIdentical node constructor

func (*NotIdentical) Attributes 

func (n *NotIdentical) Attributes() map[string]interface{}

Attributes returns node attributes as map

func (*NotIdentical) GetFreeFloating 

func (n *NotIdentical) GetFreeFloating() *freefloating.Collection

func (*NotIdentical) GetPosition 

func (n *NotIdentical) GetPosition() *position.Position

GetPosition returns node positions

func (*NotIdentical) SetPosition 

func (n *NotIdentical) SetPosition(p *position.Position)

SetPosition sets node position

func (*NotIdentical) Walk 

func (n *NotIdentical) Walk(v walker.Visitor)

Walk traverses nodes Walk is invoked recursively until v.EnterNode returns true

type Plus 

type Plus struct {
	FreeFloating freefloating.Collection
	Position     *position.Position
	Left         node.Node
	Right        node.Node
}

Plus node

func NewPlus 

func NewPlus(Variable node.Node, Expression node.Node) *Plus

NewPlus node constructor

func (*Plus) Attributes 

func (n *Plus) Attributes() map[string]interface{}

Attributes returns node attributes as map

func (*Plus) GetFreeFloating 

func (n *Plus) GetFreeFloating() *freefloating.Collection

func (*Plus) GetPosition 

func (n *Plus) GetPosition() *position.Position

GetPosition returns node positions

func (*Plus) SetPosition 

func (n *Plus) SetPosition(p *position.Position)

SetPosition sets node position

func (*Plus) Walk 

func (n *Plus) Walk(v walker.Visitor)

Walk traverses nodes Walk is invoked recursively until v.EnterNode returns true

type Pow 

type Pow struct {
	FreeFloating freefloating.Collection
	Position     *position.Position
	Left         node.Node
	Right        node.Node
}

Pow node

func NewPow 

func NewPow(Variable node.Node, Expression node.Node) *Pow

NewPow node constructor

func (*Pow) Attributes 

func (n *Pow) Attributes() map[string]interface{}

Attributes returns node attributes as map

func (*Pow) GetFreeFloating 

func (n *Pow) GetFreeFloating() *freefloating.Collection

func (*Pow) GetPosition 

func (n *Pow) GetPosition() *position.Position

GetPosition returns node positions

func (*Pow) SetPosition 

func (n *Pow) SetPosition(p *position.Position)

SetPosition sets node position

func (*Pow) Walk 

func (n *Pow) Walk(v walker.Visitor)

Walk traverses nodes Walk is invoked recursively until v.EnterNode returns true

type ShiftLeft 

type ShiftLeft struct {
	FreeFloating freefloating.Collection
	Position     *position.Position
	Left         node.Node
	Right        node.Node
}

ShiftLeft node

func NewShiftLeft 

func NewShiftLeft(Variable node.Node, Expression node.Node) *ShiftLeft

NewShiftLeft node constructor

func (*ShiftLeft) Attributes 

func (n *ShiftLeft) Attributes() map[string]interface{}

Attributes returns node attributes as map

func (*ShiftLeft) GetFreeFloating 

func (n *ShiftLeft) GetFreeFloating() *freefloating.Collection

func (*ShiftLeft) GetPosition 

func (n *ShiftLeft) GetPosition() *position.Position

GetPosition returns node positions

func (*ShiftLeft) SetPosition 

func (n *ShiftLeft) SetPosition(p *position.Position)

SetPosition sets node position

func (*ShiftLeft) Walk 

func (n *ShiftLeft) Walk(v walker.Visitor)

Walk traverses nodes Walk is invoked recursively until v.EnterNode returns true

type ShiftRight 

type ShiftRight struct {
	FreeFloating freefloating.Collection
	Position     *position.Position
	Left         node.Node
	Right        node.Node
}

ShiftRight node

func NewShiftRight 

func NewShiftRight(Variable node.Node, Expression node.Node) *ShiftRight

NewShiftRight node constructor

func (*ShiftRight) Attributes 

func (n *ShiftRight) Attributes() map[string]interface{}

Attributes returns node attributes as map

func (*ShiftRight) GetFreeFloating 

func (n *ShiftRight) GetFreeFloating() *freefloating.Collection

func (*ShiftRight) GetPosition 

func (n *ShiftRight) GetPosition() *position.Position

GetPosition returns node positions

func (*ShiftRight) SetPosition 

func (n *ShiftRight) SetPosition(p *position.Position)

SetPosition sets node position

func (*ShiftRight) Walk 

func (n *ShiftRight) Walk(v walker.Visitor)

Walk traverses nodes Walk is invoked recursively until v.EnterNode returns true

type Smaller 

type Smaller struct {
	FreeFloating freefloating.Collection
	Position     *position.Position
	Left         node.Node
	Right        node.Node
}

Smaller node

func NewSmaller 

func NewSmaller(Variable node.Node, Expression node.Node) *Smaller

NewSmaller node constructor

func (*Smaller) Attributes 

func (n *Smaller) Attributes() map[string]interface{}

Attributes returns node attributes as map

func (*Smaller) GetFreeFloating 

func (n *Smaller) GetFreeFloating() *freefloating.Collection

func (*Smaller) GetPosition 

func (n *Smaller) GetPosition() *position.Position

GetPosition returns node positions

func (*Smaller) SetPosition 

func (n *Smaller) SetPosition(p *position.Position)

SetPosition sets node position

func (*Smaller) Walk 

func (n *Smaller) Walk(v walker.Visitor)

Walk traverses nodes Walk is invoked recursively until v.EnterNode returns true

type SmallerOrEqual 

type SmallerOrEqual struct {
	FreeFloating freefloating.Collection
	Position     *position.Position
	Left         node.Node
	Right        node.Node
}

SmallerOrEqual node

func NewSmallerOrEqual 

func NewSmallerOrEqual(Variable node.Node, Expression node.Node) *SmallerOrEqual

NewSmallerOrEqual node constructor

func (*SmallerOrEqual) Attributes 

func (n *SmallerOrEqual) Attributes() map[string]interface{}

Attributes returns node attributes as map

func (*SmallerOrEqual) GetFreeFloating 

func (n *SmallerOrEqual) GetFreeFloating() *freefloating.Collection

func (*SmallerOrEqual) GetPosition 

func (n *SmallerOrEqual) GetPosition() *position.Position

GetPosition returns node positions

func (*SmallerOrEqual) SetPosition 

func (n *SmallerOrEqual) SetPosition(p *position.Position)

SetPosition sets node position

func (*SmallerOrEqual) Walk 

func (n *SmallerOrEqual) Walk(v walker.Visitor)

Walk traverses nodes Walk is invoked recursively until v.EnterNode returns true

type Spaceship 

type Spaceship struct {
	FreeFloating freefloating.Collection
	Position     *position.Position
	Left         node.Node
	Right        node.Node
}

Spaceship node

func NewSpaceship 

func NewSpaceship(Variable node.Node, Expression node.Node) *Spaceship

NewSpaceship node constructor

func (*Spaceship) Attributes 

func (n *Spaceship) Attributes() map[string]interface{}

Attributes returns node attributes as map

func (*Spaceship) GetFreeFloating 

func (n *Spaceship) GetFreeFloating() *freefloating.Collection

func (*Spaceship) GetPosition 

func (n *Spaceship) GetPosition() *position.Position

GetPosition returns node positions

func (*Spaceship) SetPosition 

func (n *Spaceship) SetPosition(p *position.Position)

SetPosition sets node position

func (*Spaceship) Walk 

func (n *Spaceship) Walk(v walker.Visitor)

Walk traverses nodes Walk is invoked recursively until v.EnterNode returns true

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.