binary

package

Go to main page

Versions in this module

v0

v0.7.2

Jul 26, 2020

v0.7.1

Jun 14, 2020

v0.7.0

Mar 9, 2020

v0.6.1

Aug 20, 2019

v0.6.0

Feb 25, 2019

Changes in this version

type BitwiseAnd

+ FreeFloating freefloating.Collection

+ Position *position.Position

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

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

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

type BitwiseOr

+ FreeFloating freefloating.Collection

+ Position *position.Position

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

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

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

type BitwiseXor

+ FreeFloating freefloating.Collection

+ Position *position.Position

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

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

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

type BooleanAnd

+ FreeFloating freefloating.Collection

+ Position *position.Position

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

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

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

type BooleanOr

+ FreeFloating freefloating.Collection

+ Position *position.Position

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

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

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

type Coalesce

+ FreeFloating freefloating.Collection

+ Position *position.Position

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

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

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

type Concat

+ FreeFloating freefloating.Collection

+ Position *position.Position

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

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

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

type Div

+ FreeFloating freefloating.Collection

+ Position *position.Position

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

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

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

type Equal

+ FreeFloating freefloating.Collection

+ Position *position.Position

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

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

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

type Greater

+ FreeFloating freefloating.Collection

+ Position *position.Position

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

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

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

type GreaterOrEqual

+ FreeFloating freefloating.Collection

+ Position *position.Position

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

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

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

type Identical

+ FreeFloating freefloating.Collection

+ Position *position.Position

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

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

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

type LogicalAnd

+ FreeFloating freefloating.Collection

+ Position *position.Position

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

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

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

type LogicalOr

+ FreeFloating freefloating.Collection

+ Position *position.Position

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

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

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

type LogicalXor

+ FreeFloating freefloating.Collection

+ Position *position.Position

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

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

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

type Minus

+ FreeFloating freefloating.Collection

+ Position *position.Position

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

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

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

type Mod

+ FreeFloating freefloating.Collection

+ Position *position.Position

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

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

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

type Mul

+ FreeFloating freefloating.Collection

+ Position *position.Position

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

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

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

type NotEqual

+ FreeFloating freefloating.Collection

+ Position *position.Position

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

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

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

type NotIdentical

+ FreeFloating freefloating.Collection

+ Position *position.Position

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

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

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

type Plus

+ FreeFloating freefloating.Collection

+ Position *position.Position

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

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

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

type Pow

+ FreeFloating freefloating.Collection

+ Position *position.Position

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

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

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

type ShiftLeft

+ FreeFloating freefloating.Collection

+ Position *position.Position

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

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

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

type ShiftRight

+ FreeFloating freefloating.Collection

+ Position *position.Position

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

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

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

type Smaller

+ FreeFloating freefloating.Collection

+ Position *position.Position

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

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

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

type SmallerOrEqual

+ FreeFloating freefloating.Collection

+ Position *position.Position

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

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

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

type Spaceship

+ FreeFloating freefloating.Collection

+ Position *position.Position

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

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

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

v0.5.1

Jun 26, 2018

v0.5.0

Jun 7, 2018

v0.4.0

Apr 6, 2018

v0.3.0

Mar 1, 2018

Changes in this version

+ type BitwiseAnd struct

+ Left node.Node

+ Right node.Node

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

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

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

+ type BitwiseOr struct

+ Left node.Node

+ Right node.Node

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

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

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

+ type BitwiseXor struct

+ Left node.Node

+ Right node.Node

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

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

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

+ type BooleanAnd struct

+ Left node.Node

+ Right node.Node

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

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

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

+ type BooleanOr struct

+ Left node.Node

+ Right node.Node

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

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

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

+ type Coalesce struct

+ Left node.Node

+ Right node.Node

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

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

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

+ type Concat struct

+ Left node.Node

+ Right node.Node

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

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

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

+ type Div struct

+ Left node.Node

+ Right node.Node

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

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

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

+ type Equal struct

+ Left node.Node

+ Right node.Node

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

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

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

+ type Greater struct

+ Left node.Node

+ Right node.Node

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

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

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

+ type GreaterOrEqual struct

+ Left node.Node

+ Right node.Node

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

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

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

+ type Identical struct

+ Left node.Node

+ Right node.Node

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

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

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

+ type LogicalAnd struct

+ Left node.Node

+ Right node.Node

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

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

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

+ type LogicalOr struct

+ Left node.Node

+ Right node.Node

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

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

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

+ type LogicalXor struct

+ Left node.Node

+ Right node.Node

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

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

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

+ type Minus struct

+ Left node.Node

+ Right node.Node

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

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

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

+ type Mod struct

+ Left node.Node

+ Right node.Node

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

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

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

+ type Mul struct

+ Left node.Node

+ Right node.Node

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

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

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

+ type NotEqual struct

+ Left node.Node

+ Right node.Node

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

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

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

+ type NotIdentical struct

+ Left node.Node

+ Right node.Node

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

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

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

+ type Plus struct

+ Left node.Node

+ Right node.Node

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

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

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

+ type Pow struct

+ Left node.Node

+ Right node.Node

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

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

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

+ type ShiftLeft struct

+ Left node.Node

+ Right node.Node

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

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

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

+ type ShiftRight struct

+ Left node.Node

+ Right node.Node

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

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

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

+ type Smaller struct

+ Left node.Node

+ Right node.Node

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

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

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

+ type SmallerOrEqual struct

+ Left node.Node

+ Right node.Node

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

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

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

+ type Spaceship struct

+ Left node.Node

+ Right node.Node

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

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

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

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