binary

package

Go to main page

Versions in this module

v0

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