rulesengine

package
v1.0.17 Latest Latest
Warning

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

 Go to latest Published: Jan 28, 2026 License: Apache-2.0, BSD-3-Clause Imports: 20 Imported by: 11

Documentation

Overview

*

  • Copyright 2022 Comcast Cable Communications Management, LLC *
  • Licensed under the Apache License, Version 2.0 (the "License");
  • you may not use this file except in compliance with the License.
  • You may obtain a copy of the License at *
  • http://www.apache.org/licenses/LICENSE-2.0 *
  • Unless required by applicable law or agreed to in writing, software
  • distributed under the License is distributed on an "AS IS" BASIS,
  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  • See the License for the specific language governing permissions and
  • limitations under the License. *
  • SPDX-License-Identifier: Apache-2.0

*

  • Copyright 2022 Comcast Cable Communications Management, LLC *
  • Licensed under the Apache License, Version 2.0 (the "License");
  • you may not use this file except in compliance with the License.
  • You may obtain a copy of the License at *
  • http://www.apache.org/licenses/LICENSE-2.0 *
  • Unless required by applicable law or agreed to in writing, software
  • distributed under the License is distributed on an "AS IS" BASIS,
  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  • See the License for the specific language governing permissions and
  • limitations under the License. *
  • SPDX-License-Identifier: Apache-2.0

*

  • Copyright 2022 Comcast Cable Communications Management, LLC *
  • Licensed under the Apache License, Version 2.0 (the "License");
  • you may not use this file except in compliance with the License.
  • You may obtain a copy of the License at *
  • http://www.apache.org/licenses/LICENSE-2.0 *
  • Unless required by applicable law or agreed to in writing, software
  • distributed under the License is distributed on an "AS IS" BASIS,
  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  • See the License for the specific language governing permissions and
  • limitations under the License. *
  • SPDX-License-Identifier: Apache-2.0

*

  • Copyright 2022 Comcast Cable Communications Management, LLC *
  • Licensed under the Apache License, Version 2.0 (the "License");
  • you may not use this file except in compliance with the License.
  • You may obtain a copy of the License at *
  • http://www.apache.org/licenses/LICENSE-2.0 *
  • Unless required by applicable law or agreed to in writing, software
  • distributed under the License is distributed on an "AS IS" BASIS,
  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  • See the License for the specific language governing permissions and
  • limitations under the License. *
  • SPDX-License-Identifier: Apache-2.0

*

  • Copyright 2022 Comcast Cable Communications Management, LLC *
  • Licensed under the Apache License, Version 2.0 (the "License");
  • you may not use this file except in compliance with the License.
  • You may obtain a copy of the License at *
  • http://www.apache.org/licenses/LICENSE-2.0 *
  • Unless required by applicable law or agreed to in writing, software
  • distributed under the License is distributed on an "AS IS" BASIS,
  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  • See the License for the specific language governing permissions and
  • limitations under the License. *
  • SPDX-License-Identifier: Apache-2.0

*

  • Copyright 2022 Comcast Cable Communications Management, LLC *
  • Licensed under the Apache License, Version 2.0 (the "License");
  • you may not use this file except in compliance with the License.
  • You may obtain a copy of the License at *
  • http://www.apache.org/licenses/LICENSE-2.0 *
  • Unless required by applicable law or agreed to in writing, software
  • distributed under the License is distributed on an "AS IS" BASIS,
  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  • See the License for the specific language governing permissions and
  • limitations under the License. *
  • SPDX-License-Identifier: Apache-2.0

*

  • Copyright 2022 Comcast Cable Communications Management, LLC *
  • Licensed under the Apache License, Version 2.0 (the "License");
  • you may not use this file except in compliance with the License.
  • You may obtain a copy of the License at *
  • http://www.apache.org/licenses/LICENSE-2.0 *
  • Unless required by applicable law or agreed to in writing, software
  • distributed under the License is distributed on an "AS IS" BASIS,
  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  • See the License for the specific language governing permissions and
  • limitations under the License. *
  • SPDX-License-Identifier: Apache-2.0

*

  • Copyright 2022 Comcast Cable Communications Management, LLC *
  • Licensed under the Apache License, Version 2.0 (the "License");
  • you may not use this file except in compliance with the License.
  • You may obtain a copy of the License at *
  • http://www.apache.org/licenses/LICENSE-2.0 *
  • Unless required by applicable law or agreed to in writing, software
  • distributed under the License is distributed on an "AS IS" BASIS,
  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  • See the License for the specific language governing permissions and
  • limitations under the License. *
  • SPDX-License-Identifier: Apache-2.0

*

  • Copyright 2022 Comcast Cable Communications Management, LLC *
  • Licensed under the Apache License, Version 2.0 (the "License");
  • you may not use this file except in compliance with the License.
  • You may obtain a copy of the License at *
  • http://www.apache.org/licenses/LICENSE-2.0 *
  • Unless required by applicable law or agreed to in writing, software
  • distributed under the License is distributed on an "AS IS" BASIS,
  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  • See the License for the specific language governing permissions and
  • limitations under the License. *
  • SPDX-License-Identifier: Apache-2.0

*

  • Copyright 2022 Comcast Cable Communications Management, LLC *
  • Licensed under the Apache License, Version 2.0 (the "License");
  • you may not use this file except in compliance with the License.
  • You may obtain a copy of the License at *
  • http://www.apache.org/licenses/LICENSE-2.0 *
  • Unless required by applicable law or agreed to in writing, software
  • distributed under the License is distributed on an "AS IS" BASIS,
  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  • See the License for the specific language governing permissions and
  • limitations under the License. *
  • SPDX-License-Identifier: Apache-2.0

*

  • Copyright 2022 Comcast Cable Communications Management, LLC *
  • Licensed under the Apache License, Version 2.0 (the "License");
  • you may not use this file except in compliance with the License.
  • You may obtain a copy of the License at *
  • http://www.apache.org/licenses/LICENSE-2.0 *
  • Unless required by applicable law or agreed to in writing, software
  • distributed under the License is distributed on an "AS IS" BASIS,
  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  • See the License for the specific language governing permissions and
  • limitations under the License. *
  • SPDX-License-Identifier: Apache-2.0

*

  • Copyright 2022 Comcast Cable Communications Management, LLC *
  • Licensed under the Apache License, Version 2.0 (the "License");
  • you may not use this file except in compliance with the License.
  • You may obtain a copy of the License at *
  • http://www.apache.org/licenses/LICENSE-2.0 *
  • Unless required by applicable law or agreed to in writing, software
  • distributed under the License is distributed on an "AS IS" BASIS,
  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  • See the License for the specific language governing permissions and
  • limitations under the License. *
  • SPDX-License-Identifier: Apache-2.0

*

  • Copyright 2022 Comcast Cable Communications Management, LLC *
  • Licensed under the Apache License, Version 2.0 (the "License");
  • you may not use this file except in compliance with the License.
  • You may obtain a copy of the License at *
  • http://www.apache.org/licenses/LICENSE-2.0 *
  • Unless required by applicable law or agreed to in writing, software
  • distributed under the License is distributed on an "AS IS" BASIS,
  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  • See the License for the specific language governing permissions and
  • limitations under the License. *
  • SPDX-License-Identifier: Apache-2.0

*

  • Copyright 2022 Comcast Cable Communications Management, LLC *
  • Licensed under the Apache License, Version 2.0 (the "License");
  • you may not use this file except in compliance with the License.
  • You may obtain a copy of the License at *
  • http://www.apache.org/licenses/LICENSE-2.0 *
  • Unless required by applicable law or agreed to in writing, software
  • distributed under the License is distributed on an "AS IS" BASIS,
  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  • See the License for the specific language governing permissions and
  • limitations under the License. *
  • SPDX-License-Identifier: Apache-2.0

*

  • Copyright 2022 Comcast Cable Communications Management, LLC *
  • Licensed under the Apache License, Version 2.0 (the "License");
  • you may not use this file except in compliance with the License.
  • You may obtain a copy of the License at *
  • http://www.apache.org/licenses/LICENSE-2.0 *
  • Unless required by applicable law or agreed to in writing, software
  • distributed under the License is distributed on an "AS IS" BASIS,
  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  • See the License for the specific language governing permissions and
  • limitations under the License. *
  • SPDX-License-Identifier: Apache-2.0

Index

Constants

View Source 
const (
	StandardFreeArgTypeString = "STRING"
	StandardFreeArgTypeLong   = "LONG"
	StandardFreeArgTypeVoid   = "VOID"
	StandardFreeArgTypeAny    = "ANY"

	StandardOperationIs         = "IS"
	StandardOperationGt         = "GT"
	StandardOperationGte        = "GTE"
	StandardOperationLt         = "LT"
	StandardOperationLte        = "LTE"
	StandardOperationLike       = "LIKE"
	StandardOperationIn         = "IN"
	StandardOperationAnyMatched = "ANY_MATCHED"
	StandardOperationPercent    = "PERCENT"
	StandardOperationExists     = "EXISTS"
	StandardOperationInList     = "IN_LIST"
	StandardOperationMatch      = "MATCH"
	StandardOperationRange      = "RANGE"

	AuxFreeArgTypeTime       = "TIME"
	AuxFreeArgTypeIpAddress  = "IP_ADDRESS"
	AuxFreeArgTypeMacAddress = "MAC_ADDRESS"

	RelationOr  = "OR"
	RelationAnd = "AND"
)
View Source 
const (
	LeftParan  = "("
	RightParan = ")"
	SpaceChar  = " "
)

Variables

View Source 
var SipHashKey = [16]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}
View Source 
var UseMap bool

Functions

func ChangeFixedArgToNewValue 

func ChangeFixedArgToNewValue(oldFixedArgValue string, newFixedArgValue string, rule Rule, operation string) bool

func CheckFreeArgExists2 

func CheckFreeArgExists2(conditionInfos []ConditionInfo, freeArg FreeArg) error

func CheckFreeArgExists3 

func CheckFreeArgExists3(conditionInfos []ConditionInfo, freeArg FreeArg, operation string) error

func CompareRules 

func CompareRules(r1 Rule, r2 Rule) int

*

  • provides compareTo implementation compatible with {@code java.util.Comparator<Rule>}
  • that can be used for rule ordering since it takes into account both rule
  • and priority of operations (ascending PERCENT < LIKE < IN < IS) *
  • @param r1 first rule to compare
  • @param r2 second rule to compare
  • @return comparison result according to {@link java.util.Comparator#compare(Object, Object)}

func ConditionHasEmptyElements 

func ConditionHasEmptyElements(rule Rule) bool

func EqualComplexRules 

func EqualComplexRules(rule1 *Rule, rule2 *Rule) bool

func FitsPercent 

func FitsPercent(itf interface{}, percent float64) bool

func FreeArgExists 

func FreeArgExists(conditionInfos []ConditionInfo, freeArg FreeArg) bool

func FreeArgExists2 

func FreeArgExists2(conditionInfos []ConditionInfo, freeArg FreeArg, operation string) bool

func GetDuplicateFixedArgListItems 

func GetDuplicateFixedArgListItems(fixedArg FixedArg) (retList []string)

func GetFixedArgFromConditionByFreeArgAndOperation 

func GetFixedArgFromConditionByFreeArgAndOperation(condition Condition, freeArg string, operation string) interface{}

func GetFixedArgFromConditionByOperation 

func GetFixedArgFromConditionByOperation(condition *Condition, operation string) interface{}

func GetFixedArgsFromRuleByFreeArgAndOperation 

func GetFixedArgsFromRuleByFreeArgAndOperation(rule Rule, freeArg string, operation string) []string

func GetFixedArgsFromRuleByOperation 

func GetFixedArgsFromRuleByOperation(rule *Rule, operation string) []string

func IsExistConditionByFixedArgValue 

func IsExistConditionByFixedArgValue(rule Rule, fixedArgValue string) bool

func IsExistConditionByFreeArgAndFixedArg 

func IsExistConditionByFreeArgAndFixedArg(rule *Rule, freeArg string, fixedArg string) bool

func IsExistConditionByFreeArgName 

func IsExistConditionByFreeArgName(rule Rule, freeArgName string) bool

func IsExistPartOfSearchValueInFixedArgs 

func IsExistPartOfSearchValueInFixedArgs(fixedArgs *Collection, searchValue string) bool

func NormalizeCondition 

func NormalizeCondition(condition *Condition) error

func NormalizeConditions 

func NormalizeConditions(rule *Rule) error

func RemElemFromRuleList 

func RemElemFromRuleList(rules []*Rule) (*Rule, []*Rule)

RemElemFromRuleList ... remove / popup a element from slice

Types

type BaseEvaluator 

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

func NewBaseEvaluator 

func NewBaseEvaluator(freeArgType string, operation string, evaluateInternal FnEvaluateInternal) *BaseEvaluator

func (*BaseEvaluator) Evaluate 

func (e *BaseEvaluator) Evaluate(condition *Condition, context map[string]string) bool

func (*BaseEvaluator) FreeArgType 

func (e *BaseEvaluator) FreeArgType() string

func (*BaseEvaluator) Operation 

func (e *BaseEvaluator) Operation() string

func (*BaseEvaluator) Validate 

func (e *BaseEvaluator) Validate(fixedArg *FixedArg) error

TODO eval if this is necessary

type BaseTimeEvaluator 

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

func NewBaseTimeEvaluator 

func NewBaseTimeEvaluator(freeArgType string, operation string, fn FnIntEval) *BaseTimeEvaluator

func (*BaseTimeEvaluator) Evaluate 

func (e *BaseTimeEvaluator) Evaluate(c *Condition, context map[string]string) bool

func (*BaseTimeEvaluator) FreeArgType 

func (e *BaseTimeEvaluator) FreeArgType() string

func (*BaseTimeEvaluator) Operation 

func (e *BaseTimeEvaluator) Operation() string

type Bean 

type Bean struct {
	Value Value `json:"value"`
}

func (*Bean) UnmarshalJSON 

func (b *Bean) UnmarshalJSON(bbytes []byte) error

type Collection 

type Collection struct {
	// Cannot specify omitempty for this field otherwise XConf Java will not be able to deserialize the JSON
	Value []string `json:"value"`
}

func (*Collection) MarshalJSON 

func (c *Collection) MarshalJSON() ([]byte, error)

type ComparingEvaluator 

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

func NewComparingEvaluator 

func NewComparingEvaluator(freeArgType string, operation string, fn FnEvaluation) *ComparingEvaluator

func (*ComparingEvaluator) Evaluate 

func (e *ComparingEvaluator) Evaluate(condition *Condition, context map[string]string) bool

func (*ComparingEvaluator) FreeArgType 

func (e *ComparingEvaluator) FreeArgType() string

func (*ComparingEvaluator) Operation 

func (e *ComparingEvaluator) Operation() string

type Condition 

type Condition struct {
	FreeArg   *FreeArg  `json:"freeArg"`
	Operation string    `json:"operation"`
	FixedArg  *FixedArg `json:"fixedArg"`
}

func GetDuplicateConditions 

func GetDuplicateConditions(conditions []Condition) (result []Condition)

func GetDuplicateConditionsBetweenOR 

func GetDuplicateConditionsBetweenOR(rule Rule) (result []Condition)

func GetDuplicateConditionsForAdmin 

func GetDuplicateConditionsForAdmin(conditions []Condition) (result []Condition)

func GetDuplicateConditionsFromRule 

func GetDuplicateConditionsFromRule(rule Rule) (result []Condition)

func NewCondition 

func NewCondition(freeArg *FreeArg, operation string, fixedArg *FixedArg) *Condition

func ToConditions 

func ToConditions(rule *Rule) []*Condition

func (*Condition) Copy 

func (c *Condition) Copy() *Condition

func (*Condition) Equals 

func (c *Condition) Equals(x *Condition) bool

func (*Condition) GetFixedArg 

func (c *Condition) GetFixedArg() *FixedArg

func (*Condition) GetFreeArg 

func (c *Condition) GetFreeArg() *FreeArg

func (*Condition) GetOperation 

func (c *Condition) GetOperation() string

func (*Condition) MarshalJSON 

func (c *Condition) MarshalJSON() ([]byte, error)

func (*Condition) SetFixedArg 

func (c *Condition) SetFixedArg(fixedArg *FixedArg)

func (*Condition) SetFreeArg 

func (c *Condition) SetFreeArg(freeArg *FreeArg)

func (*Condition) SetOperation 

func (c *Condition) SetOperation(operation string)

func (*Condition) String 

func (c *Condition) String() string

type ConditionInfo 

type ConditionInfo struct {
	FreeArg   FreeArg
	Operation string
}

ConditionInfo is ...

func GetConditionInfos 

func GetConditionInfos(conditions []*Condition) (result []ConditionInfo)

func NewConditionInfo 

func NewConditionInfo(freeArg FreeArg, operation string) *ConditionInfo

NewConditionInfo create a new instance

type FixedArg 

type FixedArg struct {
	Bean       *Bean       `json:"bean,omitempty"`
	Collection *Collection `json:"collection,omitempty"`
}

func NewFixedArg 

func NewFixedArg(itf interface{}) *FixedArg

func (*FixedArg) Copy 

func (a *FixedArg) Copy() *FixedArg

func (*FixedArg) Equals 

func (a *FixedArg) Equals(x *FixedArg) bool

func (*FixedArg) GetValue 

func (a *FixedArg) GetValue() interface{}

func (*FixedArg) IsCollectionValue 

func (a *FixedArg) IsCollectionValue() bool

func (*FixedArg) IsDoubleValue 

func (a *FixedArg) IsDoubleValue() bool

func (*FixedArg) IsStringValue 

func (a *FixedArg) IsStringValue() bool

func (*FixedArg) IsValid 

func (a *FixedArg) IsValid() bool

func (*FixedArg) String 

func (a *FixedArg) String() string

type FnEvaluateInternal 

type FnEvaluateInternal func(string, interface{}) bool

type FnEvaluation 

type FnEvaluation func(int) bool

type FnIntEval 

type FnIntEval func(int) bool

NOTE: 

The development of this function is postponed because I think this type is not used
in the current prod/ci data set.

type FreeArg 

type FreeArg struct {
	Type string `json:"type"`
	Name string `json:"name"`
}

func NewFreeArg 

func NewFreeArg(ttype string, name string) *FreeArg

func (*FreeArg) Copy 

func (a *FreeArg) Copy() *FreeArg

func (*FreeArg) Equals 

func (a *FreeArg) Equals(x *FreeArg) bool

func (*FreeArg) GetName 

func (a *FreeArg) GetName() string

func (*FreeArg) GetType 

func (a *FreeArg) GetType() string

func (*FreeArg) SetName 

func (a *FreeArg) SetName(name string)

func (*FreeArg) SetType 

func (a *FreeArg) SetType(ttype string)

func (*FreeArg) String 

func (a *FreeArg) String() string

type IConditionEvaluator 

type IConditionEvaluator interface {
	Evaluate(*Condition, map[string]string) bool
	FreeArgType() string
	Operation() string
}

func GetAuxEvaluators 

func GetAuxEvaluators() []IConditionEvaluator

func GetComparingEvaluators 

func GetComparingEvaluators(freeArgType string) []IConditionEvaluator

func GetStandardEvaluators 

func GetStandardEvaluators() []IConditionEvaluator

type IpAddressEvaluator 

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

func NewIpAddressEvaluator 

func NewIpAddressEvaluator(freeArgType string, operation string, nsListDao db.CachedSimpleDao) *IpAddressEvaluator

func (*IpAddressEvaluator) Evaluate 

func (e *IpAddressEvaluator) Evaluate(condition *Condition, context map[string]string) bool

func (*IpAddressEvaluator) FreeArgType 

func (e *IpAddressEvaluator) FreeArgType() string

func (*IpAddressEvaluator) Operation 

func (e *IpAddressEvaluator) Operation() string

type Parser 

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

func NewParser 

func NewParser(str string) *Parser

type Rule 

type Rule struct {
	CompoundParts []Rule     `json:"compoundParts,omitempty"`
	Condition     *Condition `json:"condition,omitempty"`
	Negated       bool       `json:"negated"`
	Relation      string     `json:"relation,omitempty"`
	Xxid          string     `json:"xxid,omitempty"` // temp use for testing
}

func And 

func And(r Rule) Rule

func AndRules 

func AndRules(base Rule, compound Rule) Rule

func Copy 

func Copy(r Rule) Rule

func FlattenRule 

func FlattenRule(r Rule) []Rule

func NewEmptyRule 

func NewEmptyRule() *Rule

func Not 

func Not(r Rule) Rule

func Or 

func Or(r Rule) Rule

func OrRules 

func OrRules(base Rule, compound Rule) Rule

func (*Rule) AddCompoundPart 

func (r *Rule) AddCompoundPart(rule Rule)

func (*Rule) Equals 

func (r *Rule) Equals(x *Rule) bool

NOTE: my understanding is the ordering of the CompoundParts matters

func (*Rule) GetCompoundParts 

func (r *Rule) GetCompoundParts() []Rule

func (*Rule) GetCondition 

func (r *Rule) GetCondition() *Condition

func (*Rule) GetFreeArg 

func (r *Rule) GetFreeArg() *FreeArg

func (*Rule) GetInListNames 

func (r *Rule) GetInListNames() []string

func (*Rule) GetRelation 

func (r *Rule) GetRelation() string

func (*Rule) GetTree 

func (r *Rule) GetTree() string

func (*Rule) Id 

func (r *Rule) Id() string

func (*Rule) IsCompound 

func (r *Rule) IsCompound() bool

func (*Rule) IsCompoundPartsEmpty 

func (r *Rule) IsCompoundPartsEmpty() bool

func (*Rule) IsEmpty 

func (r *Rule) IsEmpty() bool

func (*Rule) IsNegated 

func (r *Rule) IsNegated() bool

func (*Rule) SetCompoundParts 

func (r *Rule) SetCompoundParts(compoundParts []Rule)

func (*Rule) SetCondition 

func (r *Rule) SetCondition(condition *Condition)

func (*Rule) SetId 

func (r *Rule) SetId(xxid string)

func (*Rule) SetNegated 

func (r *Rule) SetNegated(negated bool)

func (*Rule) SetRelation 

func (r *Rule) SetRelation(relation string)

func (*Rule) String 

func (r *Rule) String() string

type RuleProcessor 

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

func NewRuleProcessor 

func NewRuleProcessor() *RuleProcessor

func (*RuleProcessor) AddEvaluators 

func (p *RuleProcessor) AddEvaluators(evs []IConditionEvaluator)

func (*RuleProcessor) Evaluate 

func (p *RuleProcessor) Evaluate(r *Rule, context map[string]string, fields log.Fields, vargNegations ...bool) bool

func (*RuleProcessor) EvaluateTest 

func (p *RuleProcessor) EvaluateTest(r *Rule, context map[string]string, fields log.Fields, vargNegations ...bool) bool

func (*RuleProcessor) Filter 

func (p *RuleProcessor) Filter(rules []Rule, context map[string]string) []Rule

func (*RuleProcessor) GetEvaluatorOK 

func (p *RuleProcessor) GetEvaluatorOK(r *Rule) bool

func (*RuleProcessor) Size 

func (p *RuleProcessor) Size() int

type RuleProcessorFactory 

type RuleProcessorFactory struct {
	Processor *RuleProcessor
}

func NewRuleProcessorFactory 

func NewRuleProcessorFactory() *RuleProcessorFactory

func (*RuleProcessorFactory) RuleProcessor 

func (f *RuleProcessorFactory) RuleProcessor() *RuleProcessor

type Value 

type Value struct {
	JLString *string  `json:"java.lang.String,omitempty"`
	JLDouble *float64 `json:"java.lang.Double,omitempty"`
}

TODO use fixed fields for simplicity for now

type XRule 

type XRule interface {
	GetId() string
	GetRule() *Rule
	GetName() string
	GetTemplateId() string
	GetRuleType() string
}

XRule is ...

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.