filter

package
v0.0.0-...-47ace37 Latest Latest
Warning

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

 Go to latest Published: Oct 9, 2018 License: MIT Imports: 12 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	OpEqual              = "eq"
	OpNotEqual           = "ne"
	OpContains           = "co"
	OpStartsWith         = "sw"
	OpEndsWith           = "ew"
	OpGreaterThan        = "gt"
	OpLessThan           = "lt"
	OpGreaterOrEqualThan = "ge"
	OpLessOrEqualThan    = "le"
	OpPresent            = "pr"
)

Attribute Operators

View Source 
const (
	FilterLexerAttributeName   = 1
	FilterLexerComparisonValue = 2
	FilterLexerSpace           = 3
	FilterLexerUrn             = 4
	FilterLexerColon           = 5
	FilterLexerPrOperator      = 6
	FilterLexerEqOperator      = 7
	FilterLexerNeOperator      = 8
	FilterLexerCoOperator      = 9
	FilterLexerSwOperator      = 10
	FilterLexerEwOperator      = 11
	FilterLexerGtOperator      = 12
	FilterLexerGeOperator      = 13
	FilterLexerLtOperator      = 14
	FilterLexerLeOperator      = 15
	FilterLexerAndOperator     = 16
	FilterLexerOrOperator      = 17
	FilterLexerNotOperator     = 18
	FilterLexerRxBracket       = 19
	FilterLexerLxBracket       = 20
	FilterLexerRxSquareBracket = 21
	FilterLexerDot             = 22
	FilterLexerLxSquareBracket = 23
)

FilterLexer tokens.

View Source 
const (
	FilterParserEOF             = antlr.TokenEOF
	FilterParserAttributeName   = 1
	FilterParserComparisonValue = 2
	FilterParserSpace           = 3
	FilterParserUrn             = 4
	FilterParserColon           = 5
	FilterParserPrOperator      = 6
	FilterParserEqOperator      = 7
	FilterParserNeOperator      = 8
	FilterParserCoOperator      = 9
	FilterParserSwOperator      = 10
	FilterParserEwOperator      = 11
	FilterParserGtOperator      = 12
	FilterParserGeOperator      = 13
	FilterParserLtOperator      = 14
	FilterParserLeOperator      = 15
	FilterParserAndOperator     = 16
	FilterParserOrOperator      = 17
	FilterParserNotOperator     = 18
	FilterParserRxBracket       = 19
	FilterParserLxBracket       = 20
	FilterParserRxSquareBracket = 21
	FilterParserDot             = 22
	FilterParserLxSquareBracket = 23
)

FilterParser tokens.

View Source 
const (
	FilterParserRULE_root                = 0
	FilterParserRULE_filter              = 1
	FilterParserRULE_attributeExpression = 2
	FilterParserRULE_attributePath       = 3
	FilterParserRULE_valueExpression     = 4
	FilterParserRULE_valueFilter         = 5
)

FilterParser rules.

Variables

This section is empty.

Functions

This section is empty.

Types

type And 

type And struct {
	Left  Filter
	Right Filter
}

And implements Filter, is used to represent the logical "and"

func (And) Normalize 

func (op And) Normalize(rt *core.ResourceType) Filter

func (And) String 

func (op And) String() string

type AndFilterContext 

type AndFilterContext struct {
	*FilterContext
	Left  IFilterContext
	Right IFilterContext
}

func NewAndFilterContext 

func NewAndFilterContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AndFilterContext

func (*AndFilterContext) AllFilter 

func (s *AndFilterContext) AllFilter() []IFilterContext

func (*AndFilterContext) AndOperator 

func (s *AndFilterContext) AndOperator() antlr.TerminalNode

func (*AndFilterContext) Filter 

func (s *AndFilterContext) Filter(i int) IFilterContext

func (*AndFilterContext) GetLeft 

func (s *AndFilterContext) GetLeft() IFilterContext

func (*AndFilterContext) GetRight 

func (s *AndFilterContext) GetRight() IFilterContext

func (*AndFilterContext) GetRuleContext 

func (s *AndFilterContext) GetRuleContext() antlr.RuleContext

func (*AndFilterContext) SetLeft 

func (s *AndFilterContext) SetLeft(v IFilterContext)

func (*AndFilterContext) SetRight 

func (s *AndFilterContext) SetRight(v IFilterContext)

type AndValueFilterContext 

type AndValueFilterContext struct {
	*ValueFilterContext
	Left  IAttributeExpressionContext
	Op    antlr.Token
	Right IAttributeExpressionContext
}

func NewAndValueFilterContext 

func NewAndValueFilterContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AndValueFilterContext

func (*AndValueFilterContext) AllAttributeExpression 

func (s *AndValueFilterContext) AllAttributeExpression() []IAttributeExpressionContext

func (*AndValueFilterContext) AndOperator 

func (s *AndValueFilterContext) AndOperator() antlr.TerminalNode

func (*AndValueFilterContext) AttributeExpression 

func (s *AndValueFilterContext) AttributeExpression(i int) IAttributeExpressionContext

func (*AndValueFilterContext) GetLeft 

func (s *AndValueFilterContext) GetLeft() IAttributeExpressionContext

func (*AndValueFilterContext) GetOp 

func (s *AndValueFilterContext) GetOp() antlr.Token

func (*AndValueFilterContext) GetRight 

func (s *AndValueFilterContext) GetRight() IAttributeExpressionContext

func (*AndValueFilterContext) GetRuleContext 

func (s *AndValueFilterContext) GetRuleContext() antlr.RuleContext

func (*AndValueFilterContext) SetLeft 

func (s *AndValueFilterContext) SetLeft(v IAttributeExpressionContext)

func (*AndValueFilterContext) SetOp 

func (s *AndValueFilterContext) SetOp(v antlr.Token)

func (*AndValueFilterContext) SetRight 

func (s *AndValueFilterContext) SetRight(v IAttributeExpressionContext)

type AttrExpr 

type AttrExpr struct {
	Path  attr.Path
	Op    string      // Should be an Attribute Operator
	Value interface{} // Type allowed: nil, bool, string, int64 or float64
}

AttrExpr is an attribute expression, implements both Filter and ValueFilter. When OpPresent is used, Value should be nil

func (AttrExpr) Normalize 

func (e AttrExpr) Normalize(rt *core.ResourceType) Filter

func (AttrExpr) String 

func (e AttrExpr) String() string

func (AttrExpr) ToFilter 

func (e AttrExpr) ToFilter(ctx *attr.Context) Filter

type AttributeExprFilterContext 

type AttributeExprFilterContext struct {
	*FilterContext
	AttributeExpr IAttributeExpressionContext
}

func NewAttributeExprFilterContext 

func NewAttributeExprFilterContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AttributeExprFilterContext

func (*AttributeExprFilterContext) AttributeExpression 

func (s *AttributeExprFilterContext) AttributeExpression() IAttributeExpressionContext

func (*AttributeExprFilterContext) GetAttributeExpr 

func (s *AttributeExprFilterContext) GetAttributeExpr() IAttributeExpressionContext

func (*AttributeExprFilterContext) GetRuleContext 

func (s *AttributeExprFilterContext) GetRuleContext() antlr.RuleContext

func (*AttributeExprFilterContext) SetAttributeExpr 

func (s *AttributeExprFilterContext) SetAttributeExpr(v IAttributeExpressionContext)

type AttributeExprValueFilterContext 

type AttributeExprValueFilterContext struct {
	*ValueFilterContext
	AttributeExpr IAttributeExpressionContext
}

func NewAttributeExprValueFilterContext 

func NewAttributeExprValueFilterContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *AttributeExprValueFilterContext

func (*AttributeExprValueFilterContext) AttributeExpression 

func (s *AttributeExprValueFilterContext) AttributeExpression() IAttributeExpressionContext

func (*AttributeExprValueFilterContext) GetAttributeExpr 

func (s *AttributeExprValueFilterContext) GetAttributeExpr() IAttributeExpressionContext

func (*AttributeExprValueFilterContext) GetRuleContext 

func (s *AttributeExprValueFilterContext) GetRuleContext() antlr.RuleContext

func (*AttributeExprValueFilterContext) SetAttributeExpr 

func (s *AttributeExprValueFilterContext) SetAttributeExpr(v IAttributeExpressionContext)

type AttributeExpressionContext 

type AttributeExpressionContext struct {
	*antlr.BaseParserRuleContext

	Path  IAttributePathContext
	Op    antlr.Token
	Value antlr.Token
	// contains filtered or unexported fields
}

func NewAttributeExpressionContext 

func NewAttributeExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AttributeExpressionContext

func NewEmptyAttributeExpressionContext 

func NewEmptyAttributeExpressionContext() *AttributeExpressionContext

func (*AttributeExpressionContext) AttributePath 

func (s *AttributeExpressionContext) AttributePath() IAttributePathContext

func (*AttributeExpressionContext) CoOperator 

func (s *AttributeExpressionContext) CoOperator() antlr.TerminalNode

func (*AttributeExpressionContext) ComparisonValue 

func (s *AttributeExpressionContext) ComparisonValue() antlr.TerminalNode

func (*AttributeExpressionContext) EqOperator 

func (s *AttributeExpressionContext) EqOperator() antlr.TerminalNode

func (*AttributeExpressionContext) EwOperator 

func (s *AttributeExpressionContext) EwOperator() antlr.TerminalNode

func (*AttributeExpressionContext) GeOperator 

func (s *AttributeExpressionContext) GeOperator() antlr.TerminalNode

func (*AttributeExpressionContext) GetOp 

func (s *AttributeExpressionContext) GetOp() antlr.Token

func (*AttributeExpressionContext) GetParser 

func (s *AttributeExpressionContext) GetParser() antlr.Parser

func (*AttributeExpressionContext) GetPath 

func (s *AttributeExpressionContext) GetPath() IAttributePathContext

func (*AttributeExpressionContext) GetRuleContext 

func (s *AttributeExpressionContext) GetRuleContext() antlr.RuleContext

func (*AttributeExpressionContext) GetValue 

func (s *AttributeExpressionContext) GetValue() antlr.Token

func (*AttributeExpressionContext) GtOperator 

func (s *AttributeExpressionContext) GtOperator() antlr.TerminalNode

func (*AttributeExpressionContext) IsAttributeExpressionContext 

func (*AttributeExpressionContext) IsAttributeExpressionContext()

func (*AttributeExpressionContext) LeOperator 

func (s *AttributeExpressionContext) LeOperator() antlr.TerminalNode

func (*AttributeExpressionContext) LtOperator 

func (s *AttributeExpressionContext) LtOperator() antlr.TerminalNode

func (*AttributeExpressionContext) NeOperator 

func (s *AttributeExpressionContext) NeOperator() antlr.TerminalNode

func (*AttributeExpressionContext) PrOperator 

func (s *AttributeExpressionContext) PrOperator() antlr.TerminalNode

func (*AttributeExpressionContext) SetOp 

func (s *AttributeExpressionContext) SetOp(v antlr.Token)

func (*AttributeExpressionContext) SetPath 

func (s *AttributeExpressionContext) SetPath(v IAttributePathContext)

func (*AttributeExpressionContext) SetValue 

func (s *AttributeExpressionContext) SetValue(v antlr.Token)

func (*AttributeExpressionContext) SwOperator 

func (s *AttributeExpressionContext) SwOperator() antlr.TerminalNode

func (*AttributeExpressionContext) ToStringTree 

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

type AttributePathContext 

type AttributePathContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewAttributePathContext 

func NewAttributePathContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AttributePathContext

func NewEmptyAttributePathContext 

func NewEmptyAttributePathContext() *AttributePathContext

func (*AttributePathContext) AllAttributeName 

func (s *AttributePathContext) AllAttributeName() []antlr.TerminalNode

func (*AttributePathContext) AttributeName 

func (s *AttributePathContext) AttributeName(i int) antlr.TerminalNode

func (*AttributePathContext) Dot 

func (s *AttributePathContext) Dot() antlr.TerminalNode

func (*AttributePathContext) GetParser 

func (s *AttributePathContext) GetParser() antlr.Parser

func (*AttributePathContext) GetPath 

func (s *AttributePathContext) GetPath() *attr.Path

func (*AttributePathContext) GetRuleContext 

func (s *AttributePathContext) GetRuleContext() antlr.RuleContext

func (*AttributePathContext) IsAttributePathContext 

func (*AttributePathContext) IsAttributePathContext()

func (*AttributePathContext) SetPath 

func (s *AttributePathContext) SetPath(v *attr.Path)

func (*AttributePathContext) ToStringTree 

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

func (*AttributePathContext) Urn 

func (s *AttributePathContext) Urn() antlr.TerminalNode

type Filter 

type Filter interface {
	String() string
	// Normalize returns the contestualized form of Filter for the given rt
	Normalize(rt *core.ResourceType) Filter
}

Filter is implemented by any value that has a String method, which returns a SCIM filtering expression as per https://tools.ietf.org/html/rfc7644#section-3.4.2.2, and Normalize method, which differentiates from other interfaces.

func CompileString 

func CompileString(s string) (f Filter, err error)

CompileString parses a SCIM filter string and returns, if successful, a Filter object.

type FilterContext 

type FilterContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyFilterContext 

func NewEmptyFilterContext() *FilterContext

func NewFilterContext 

func NewFilterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FilterContext

func (*FilterContext) CopyFrom 

func (s *FilterContext) CopyFrom(ctx *FilterContext)

func (*FilterContext) GetParser 

func (s *FilterContext) GetParser() antlr.Parser

func (*FilterContext) GetRuleContext 

func (s *FilterContext) GetRuleContext() antlr.RuleContext

func (*FilterContext) IsFilterContext 

func (*FilterContext) IsFilterContext()

func (*FilterContext) ToStringTree 

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

type FilterLexer 

type FilterLexer struct {
	*antlr.BaseLexer
	// contains filtered or unexported fields
}

func NewFilterLexer 

func NewFilterLexer(input antlr.CharStream) *FilterLexer

type FilterParser 

type FilterParser struct {
	*antlr.BaseParser
}

func NewFilterParser 

func NewFilterParser(input antlr.TokenStream) *FilterParser

func (*FilterParser) AttributeExpression 

func (p *FilterParser) AttributeExpression() (localctx IAttributeExpressionContext)

func (*FilterParser) AttributePath 

func (p *FilterParser) AttributePath() (localctx IAttributePathContext)

func (*FilterParser) AttributePath_Sempred 

func (p *FilterParser) AttributePath_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*FilterParser) Filter 

func (p *FilterParser) Filter() (localctx IFilterContext)

func (*FilterParser) Filter_Sempred 

func (p *FilterParser) Filter_Sempred(localctx antlr.RuleContext, predIndex int) bool

func (*FilterParser) Root 

func (p *FilterParser) Root() (localctx IRootContext)

func (*FilterParser) Sempred 

func (p *FilterParser) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool

func (*FilterParser) ValueExpression 

func (p *FilterParser) ValueExpression() (localctx IValueExpressionContext)

func (*FilterParser) ValueFilter 

func (p *FilterParser) ValueFilter() (localctx IValueFilterContext)

type Group 

type Group struct {
	Filter
}

Not implements Filter, is used to represent the precedence grouping "( )"

func (Group) Normalize 

func (op Group) Normalize(rt *core.ResourceType) Filter

func (Group) String 

func (g Group) String() string

type GroupFilterContext 

type GroupFilterContext struct {
	*FilterContext
	InnerFilter IFilterContext
}

func NewGroupFilterContext 

func NewGroupFilterContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *GroupFilterContext

func (*GroupFilterContext) Filter 

func (s *GroupFilterContext) Filter() IFilterContext

func (*GroupFilterContext) GetInnerFilter 

func (s *GroupFilterContext) GetInnerFilter() IFilterContext

func (*GroupFilterContext) GetRuleContext 

func (s *GroupFilterContext) GetRuleContext() antlr.RuleContext

func (*GroupFilterContext) LxBracket 

func (s *GroupFilterContext) LxBracket() antlr.TerminalNode

func (*GroupFilterContext) RxBracket 

func (s *GroupFilterContext) RxBracket() antlr.TerminalNode

func (*GroupFilterContext) SetInnerFilter 

func (s *GroupFilterContext) SetInnerFilter(v IFilterContext)

type GroupValueFilterContext 

type GroupValueFilterContext struct {
	*ValueFilterContext
	InnerFilter IValueFilterContext
}

func NewGroupValueFilterContext 

func NewGroupValueFilterContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *GroupValueFilterContext

func (*GroupValueFilterContext) GetInnerFilter 

func (s *GroupValueFilterContext) GetInnerFilter() IValueFilterContext

func (*GroupValueFilterContext) GetRuleContext 

func (s *GroupValueFilterContext) GetRuleContext() antlr.RuleContext

func (*GroupValueFilterContext) LxBracket 

func (s *GroupValueFilterContext) LxBracket() antlr.TerminalNode

func (*GroupValueFilterContext) RxBracket 

func (s *GroupValueFilterContext) RxBracket() antlr.TerminalNode

func (*GroupValueFilterContext) SetInnerFilter 

func (s *GroupValueFilterContext) SetInnerFilter(v IValueFilterContext)

func (*GroupValueFilterContext) ValueFilter 

func (s *GroupValueFilterContext) ValueFilter() IValueFilterContext

type IAttributeExpressionContext 

type IAttributeExpressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetOp returns the Op token.
	GetOp() antlr.Token

	// GetValue returns the Value token.
	GetValue() antlr.Token

	// SetOp sets the Op token.
	SetOp(antlr.Token)

	// SetValue sets the Value token.
	SetValue(antlr.Token)

	// GetPath returns the Path rule contexts.
	GetPath() IAttributePathContext

	// SetPath sets the Path rule contexts.
	SetPath(IAttributePathContext)

	// IsAttributeExpressionContext differentiates from other interfaces.
	IsAttributeExpressionContext()
}

IAttributeExpressionContext is an interface to support dynamic dispatch.

type IAttributePathContext 

type IAttributePathContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetPath returns the path attribute.
	GetPath() *attr.Path

	// SetPath sets the path attribute.
	SetPath(*attr.Path)

	// IsAttributePathContext differentiates from other interfaces.
	IsAttributePathContext()
}

IAttributePathContext is an interface to support dynamic dispatch.

type IFilterContext 

type IFilterContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsFilterContext differentiates from other interfaces.
	IsFilterContext()
}

IFilterContext is an interface to support dynamic dispatch.

type IRootContext 

type IRootContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsRootContext differentiates from other interfaces.
	IsRootContext()
}

IRootContext is an interface to support dynamic dispatch.

type IValueExpressionContext 

type IValueExpressionContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// GetPath returns the Path rule contexts.
	GetPath() IAttributePathContext

	// GetInnerFilter returns the InnerFilter rule contexts.
	GetInnerFilter() IValueFilterContext

	// SetPath sets the Path rule contexts.
	SetPath(IAttributePathContext)

	// SetInnerFilter sets the InnerFilter rule contexts.
	SetInnerFilter(IValueFilterContext)

	// IsValueExpressionContext differentiates from other interfaces.
	IsValueExpressionContext()
}

IValueExpressionContext is an interface to support dynamic dispatch.

type IValueFilterContext 

type IValueFilterContext interface {
	antlr.ParserRuleContext

	// GetParser returns the parser.
	GetParser() antlr.Parser

	// IsValueFilterContext differentiates from other interfaces.
	IsValueFilterContext()
}

IValueFilterContext is an interface to support dynamic dispatch.

type Not 

type Not struct {
	Filter
}

Not implements Filter, is used to represent the logical "not"

func (Not) Normalize 

func (op Not) Normalize(rt *core.ResourceType) Filter

func (Not) String 

func (op Not) String() string

type NotFilterContext 

type NotFilterContext struct {
	*FilterContext
	InnerFilter IFilterContext
}

func NewNotFilterContext 

func NewNotFilterContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NotFilterContext

func (*NotFilterContext) Filter 

func (s *NotFilterContext) Filter() IFilterContext

func (*NotFilterContext) GetInnerFilter 

func (s *NotFilterContext) GetInnerFilter() IFilterContext

func (*NotFilterContext) GetRuleContext 

func (s *NotFilterContext) GetRuleContext() antlr.RuleContext

func (*NotFilterContext) NotOperator 

func (s *NotFilterContext) NotOperator() antlr.TerminalNode

func (*NotFilterContext) RxBracket 

func (s *NotFilterContext) RxBracket() antlr.TerminalNode

func (*NotFilterContext) SetInnerFilter 

func (s *NotFilterContext) SetInnerFilter(v IFilterContext)

type NotValueFilterContext 

type NotValueFilterContext struct {
	*ValueFilterContext
	InnerFilter IValueFilterContext
}

func NewNotValueFilterContext 

func NewNotValueFilterContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *NotValueFilterContext

func (*NotValueFilterContext) GetInnerFilter 

func (s *NotValueFilterContext) GetInnerFilter() IValueFilterContext

func (*NotValueFilterContext) GetRuleContext 

func (s *NotValueFilterContext) GetRuleContext() antlr.RuleContext

func (*NotValueFilterContext) NotOperator 

func (s *NotValueFilterContext) NotOperator() antlr.TerminalNode

func (*NotValueFilterContext) RxBracket 

func (s *NotValueFilterContext) RxBracket() antlr.TerminalNode

func (*NotValueFilterContext) SetInnerFilter 

func (s *NotValueFilterContext) SetInnerFilter(v IValueFilterContext)

func (*NotValueFilterContext) ValueFilter 

func (s *NotValueFilterContext) ValueFilter() IValueFilterContext

type Or 

type Or struct {
	Left  Filter
	Right Filter
}

Or implements Filter, is used to represent the logical "or"

func (Or) Normalize 

func (op Or) Normalize(rt *core.ResourceType) Filter

func (Or) String 

func (op Or) String() string

type OrFilterContext 

type OrFilterContext struct {
	*FilterContext
	Left  IFilterContext
	Right IFilterContext
}

func NewOrFilterContext 

func NewOrFilterContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *OrFilterContext

func (*OrFilterContext) AllFilter 

func (s *OrFilterContext) AllFilter() []IFilterContext

func (*OrFilterContext) Filter 

func (s *OrFilterContext) Filter(i int) IFilterContext

func (*OrFilterContext) GetLeft 

func (s *OrFilterContext) GetLeft() IFilterContext

func (*OrFilterContext) GetRight 

func (s *OrFilterContext) GetRight() IFilterContext

func (*OrFilterContext) GetRuleContext 

func (s *OrFilterContext) GetRuleContext() antlr.RuleContext

func (*OrFilterContext) OrOperator 

func (s *OrFilterContext) OrOperator() antlr.TerminalNode

func (*OrFilterContext) SetLeft 

func (s *OrFilterContext) SetLeft(v IFilterContext)

func (*OrFilterContext) SetRight 

func (s *OrFilterContext) SetRight(v IFilterContext)

type OrValueFilterContext 

type OrValueFilterContext struct {
	*ValueFilterContext
	Left  IAttributeExpressionContext
	Op    antlr.Token
	Right IAttributeExpressionContext
}

func NewOrValueFilterContext 

func NewOrValueFilterContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *OrValueFilterContext

func (*OrValueFilterContext) AllAttributeExpression 

func (s *OrValueFilterContext) AllAttributeExpression() []IAttributeExpressionContext

func (*OrValueFilterContext) AttributeExpression 

func (s *OrValueFilterContext) AttributeExpression(i int) IAttributeExpressionContext

func (*OrValueFilterContext) GetLeft 

func (s *OrValueFilterContext) GetLeft() IAttributeExpressionContext

func (*OrValueFilterContext) GetOp 

func (s *OrValueFilterContext) GetOp() antlr.Token

func (*OrValueFilterContext) GetRight 

func (s *OrValueFilterContext) GetRight() IAttributeExpressionContext

func (*OrValueFilterContext) GetRuleContext 

func (s *OrValueFilterContext) GetRuleContext() antlr.RuleContext

func (*OrValueFilterContext) OrOperator 

func (s *OrValueFilterContext) OrOperator() antlr.TerminalNode

func (*OrValueFilterContext) SetLeft 

func (s *OrValueFilterContext) SetLeft(v IAttributeExpressionContext)

func (*OrValueFilterContext) SetOp 

func (s *OrValueFilterContext) SetOp(v antlr.Token)

func (*OrValueFilterContext) SetRight 

func (s *OrValueFilterContext) SetRight(v IAttributeExpressionContext)

type RootContext 

type RootContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyRootContext 

func NewEmptyRootContext() *RootContext

func NewRootContext 

func NewRootContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *RootContext

func (*RootContext) EOF 

func (s *RootContext) EOF() antlr.TerminalNode

func (*RootContext) Filter 

func (s *RootContext) Filter() IFilterContext

func (*RootContext) GetParser 

func (s *RootContext) GetParser() antlr.Parser

func (*RootContext) GetRuleContext 

func (s *RootContext) GetRuleContext() antlr.RuleContext

func (*RootContext) IsRootContext 

func (*RootContext) IsRootContext()

func (*RootContext) ToStringTree 

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

type ValueAnd 

type ValueAnd struct {
	Left  AttrExpr
	Right AttrExpr
}

ValueAnd implements ValueFilter, is used to represent the logical "and" within a Complex attribute filter grouping (ie. a ValuePath).

func (ValueAnd) String 

func (op ValueAnd) String() string

func (ValueAnd) ToFilter 

func (op ValueAnd) ToFilter(ctx *attr.Context) Filter

type ValueExprFilterContext 

type ValueExprFilterContext struct {
	*FilterContext
	ValueExpr IValueExpressionContext
}

func NewValueExprFilterContext 

func NewValueExprFilterContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ValueExprFilterContext

func (*ValueExprFilterContext) GetRuleContext 

func (s *ValueExprFilterContext) GetRuleContext() antlr.RuleContext

func (*ValueExprFilterContext) GetValueExpr 

func (s *ValueExprFilterContext) GetValueExpr() IValueExpressionContext

func (*ValueExprFilterContext) SetValueExpr 

func (s *ValueExprFilterContext) SetValueExpr(v IValueExpressionContext)

func (*ValueExprFilterContext) ValueExpression 

func (s *ValueExprFilterContext) ValueExpression() IValueExpressionContext

type ValueExpressionContext 

type ValueExpressionContext struct {
	*antlr.BaseParserRuleContext

	Path        IAttributePathContext
	InnerFilter IValueFilterContext
	// contains filtered or unexported fields
}

func NewEmptyValueExpressionContext 

func NewEmptyValueExpressionContext() *ValueExpressionContext

func NewValueExpressionContext 

func NewValueExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ValueExpressionContext

func (*ValueExpressionContext) AttributePath 

func (s *ValueExpressionContext) AttributePath() IAttributePathContext

func (*ValueExpressionContext) GetInnerFilter 

func (s *ValueExpressionContext) GetInnerFilter() IValueFilterContext

func (*ValueExpressionContext) GetParser 

func (s *ValueExpressionContext) GetParser() antlr.Parser

func (*ValueExpressionContext) GetPath 

func (s *ValueExpressionContext) GetPath() IAttributePathContext

func (*ValueExpressionContext) GetRuleContext 

func (s *ValueExpressionContext) GetRuleContext() antlr.RuleContext

func (*ValueExpressionContext) IsValueExpressionContext 

func (*ValueExpressionContext) IsValueExpressionContext()

func (*ValueExpressionContext) LxSquareBracket 

func (s *ValueExpressionContext) LxSquareBracket() antlr.TerminalNode

func (*ValueExpressionContext) RxSquareBracket 

func (s *ValueExpressionContext) RxSquareBracket() antlr.TerminalNode

func (*ValueExpressionContext) SetInnerFilter 

func (s *ValueExpressionContext) SetInnerFilter(v IValueFilterContext)

func (*ValueExpressionContext) SetPath 

func (s *ValueExpressionContext) SetPath(v IAttributePathContext)

func (*ValueExpressionContext) ToStringTree 

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

func (*ValueExpressionContext) ValueFilter 

func (s *ValueExpressionContext) ValueFilter() IValueFilterContext

type ValueFilter 

type ValueFilter interface {
	String() string
	// ToFilter returns an equivalent and normalized Filter assiming ValueFilter within the given ctx
	ToFilter(ctx *attr.Context) Filter
}

ValueFilter is implemented by any value that has a String method, which returns a SCIM expression for filtering Complex attributes (eg. emails[type eq "work"]) as per https://tools.ietf.org/html/rfc7644#section-3.4.2.2, and ToFilter method, which differentiates from other interfaces.

type ValueFilterContext 

type ValueFilterContext struct {
	*antlr.BaseParserRuleContext
	// contains filtered or unexported fields
}

func NewEmptyValueFilterContext 

func NewEmptyValueFilterContext() *ValueFilterContext

func NewValueFilterContext 

func NewValueFilterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ValueFilterContext

func (*ValueFilterContext) CopyFrom 

func (s *ValueFilterContext) CopyFrom(ctx *ValueFilterContext)

func (*ValueFilterContext) GetParser 

func (s *ValueFilterContext) GetParser() antlr.Parser

func (*ValueFilterContext) GetRuleContext 

func (s *ValueFilterContext) GetRuleContext() antlr.RuleContext

func (*ValueFilterContext) IsValueFilterContext 

func (*ValueFilterContext) IsValueFilterContext()

func (*ValueFilterContext) ToStringTree 

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

type ValueGroup 

type ValueGroup struct {
	ValueFilter
}

ValueGroup implements ValueFilter, is used to represent the precedence grouping "( )" within a Complex attribute filter grouping (ie. a ValuePath).

func (ValueGroup) String 

func (g ValueGroup) String() string

func (ValueGroup) ToFilter 

func (op ValueGroup) ToFilter(ctx *attr.Context) Filter

type ValueNot 

type ValueNot struct {
	ValueFilter
}

ValueNot implements ValueFilter, is used to represent the logical "not" within a Complex attribute filter grouping (ie. a ValuePath).

func (ValueNot) String 

func (op ValueNot) String() string

func (ValueNot) ToFilter 

func (op ValueNot) ToFilter(ctx *attr.Context) Filter

type ValueOr 

type ValueOr struct {
	Left  AttrExpr
	Right AttrExpr
}

ValueOr implements ValueFilter, is used to represent the logical "or" within a Complex attribute filter grouping (ie. a ValuePath).

func (ValueOr) String 

func (op ValueOr) String() string

func (ValueOr) ToFilter 

func (op ValueOr) ToFilter(ctx *attr.Context) Filter

type ValuePath 

type ValuePath struct {
	Path attr.Path
	ValueFilter
}

ValuePath implements Filter, is used to represent a value path expression (eg. emails[type eq "work" and value co "@example.com"]). The filter for Complex attribute filter grouping MUST implement the ValueFilter interface.

func (ValuePath) Normalize 

func (vp ValuePath) Normalize(rt *core.ResourceType) Filter

func (ValuePath) String 

func (vp ValuePath) String() string

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.