model

Dec 15, 2022

Changes in this version

type GoValueNode

+ func (node *GoValueNode) IsInterface() bool

type JSONValueNode

+ func (vn *JSONValueNode) IsInterface() bool

type ValueNode

+ IsInterface func() bool

Feb 21, 2022

Changes in this version

+ func StrMatchRegexPattern(str string, arg []reflect.Value) (reflect.Value, error)

May 19, 2021

Changes in this version

+ func StrIn(str string, arg []reflect.Value) (reflect.Value, error)

Dec 19, 2020

Changes in this version

+ const ANSIC

+ const Kitchen

+ const RFC1123

+ const RFC1123Z

+ const RFC3339

+ const RFC3339Nano

+ const RFC822

+ const RFC822Z

+ const RFC850

+ const RubyDate

+ const Stamp

+ const StampMicro

+ const StampMilli

+ const StampNano

+ const UnixDate

+ var DateTimeLayout = time.RFC3339

+ var TimeValidatorMap = map[string]string

+ func IsDateFormatValid(layout, date string) bool

+ type JSONValueNode struct

+ func (vn *JSONValueNode) AppendValue(value []reflect.Value) error

+ func (vn *JSONValueNode) CallFunction(funcName string, args ...reflect.Value) (reflect.Value, error)

+ func (vn *JSONValueNode) ContinueWithValue(value reflect.Value, identifiedAs string) ValueNode

+ func (vn *JSONValueNode) GetArrayType() (reflect.Type, error)

+ func (vn *JSONValueNode) GetArrayValueAt(index int) (reflect.Value, error)

+ func (vn *JSONValueNode) GetChildNodeByField(field string) (ValueNode, error)

+ func (vn *JSONValueNode) GetChildNodeByIndex(index int) (ValueNode, error)

+ func (vn *JSONValueNode) GetChildNodeBySelector(index reflect.Value) (ValueNode, error)

+ func (vn *JSONValueNode) GetMapValueAt(index reflect.Value) (reflect.Value, error)

+ func (vn *JSONValueNode) GetObjectTypeByField(field string) (reflect.Type, error)

+ func (vn *JSONValueNode) GetObjectValueByField(field string) (reflect.Value, error)

+ func (vn *JSONValueNode) GetType() (reflect.Type, error)

+ func (vn *JSONValueNode) GetValue() (reflect.Value, error)

+ func (vn *JSONValueNode) HasParent() bool

+ func (vn *JSONValueNode) IdentifiedAs() string

+ func (vn *JSONValueNode) IsArray() bool

+ func (vn *JSONValueNode) IsBool() bool

+ func (vn *JSONValueNode) IsInteger() bool

+ func (vn *JSONValueNode) IsMap() bool

+ func (vn *JSONValueNode) IsObject() bool

+ func (vn *JSONValueNode) IsReal() bool

+ func (vn *JSONValueNode) IsString() bool

+ func (vn *JSONValueNode) IsTime() bool

+ func (vn *JSONValueNode) Length() (l int, e error)

+ func (vn *JSONValueNode) Parent() ValueNode

+ func (vn *JSONValueNode) SetArrayValueAt(index int, value reflect.Value) error

+ func (vn *JSONValueNode) SetMapValueAt(index, newValue reflect.Value) error

+ func (vn *JSONValueNode) SetObjectValueByField(field string, newValue reflect.Value) error

+ func (vn *JSONValueNode) Value() reflect.Value

type ValueNode

+ func NewJSONValueNode(JSONString, identifiedAs string) (ValueNode, error)

Sep 3, 2020

Changes in this version

+ func StrLen(str string, arg []reflect.Value) (reflect.Value, error)

Sep 1, 2020

Changes in this version

+ func ArrClear(arr reflect.Value, arg []reflect.Value) (reflect.Value, error)

+ func ArrMapLen(arr reflect.Value, arg []reflect.Value) (reflect.Value, error)

+ func MapClear(amap reflect.Value, arg []reflect.Value) (reflect.Value, error)

+ func SetNumberValue(target, newvalue reflect.Value) error

+ func StrCompare(str string, arg []reflect.Value) (reflect.Value, error)

+ func StrContains(str string, arg []reflect.Value) (reflect.Value, error)

+ func StrCount(str string, arg []reflect.Value) (reflect.Value, error)

+ func StrHasPrefix(str string, arg []reflect.Value) (reflect.Value, error)

+ func StrHasSuffix(str string, arg []reflect.Value) (reflect.Value, error)

+ func StrIndex(str string, arg []reflect.Value) (reflect.Value, error)

+ func StrLastIndex(str string, arg []reflect.Value) (reflect.Value, error)

+ func StrRepeat(str string, arg []reflect.Value) (reflect.Value, error)

+ func StrReplace(str string, arg []reflect.Value) (reflect.Value, error)

+ func StrSplit(str string, arg []reflect.Value) (reflect.Value, error)

+ func StrToLower(str string, arg []reflect.Value) (reflect.Value, error)

+ func StrToUpper(str string, arg []reflect.Value) (reflect.Value, error)

+ func StrTrim(str string, arg []reflect.Value) (reflect.Value, error)

+ type GoValueNode struct

+ func (node *GoValueNode) AppendValue(value []reflect.Value) (err error)

+ func (node *GoValueNode) CallFunction(funcName string, args ...reflect.Value) (retval reflect.Value, err error)

+ func (node *GoValueNode) ContinueWithValue(value reflect.Value, identifiedAs string) ValueNode

+ func (node *GoValueNode) GetArrayType() (reflect.Type, error)

+ func (node *GoValueNode) GetArrayValueAt(index int) (reflect.Value, error)

+ func (node *GoValueNode) GetChildNodeByField(field string) (ValueNode, error)

+ func (node *GoValueNode) GetChildNodeByIndex(index int) (ValueNode, error)

+ func (node *GoValueNode) GetChildNodeBySelector(index reflect.Value) (ValueNode, error)

+ func (node *GoValueNode) GetMapValueAt(index reflect.Value) (reflect.Value, error)

+ func (node *GoValueNode) GetObjectTypeByField(field string) (typ reflect.Type, err error)

+ func (node *GoValueNode) GetObjectValueByField(field string) (reflect.Value, error)

+ func (node *GoValueNode) GetType() (reflect.Type, error)

+ func (node *GoValueNode) GetValue() (reflect.Value, error)

+ func (node *GoValueNode) HasParent() bool

+ func (node *GoValueNode) IdentifiedAs() string

+ func (node *GoValueNode) IsArray() bool

+ func (node *GoValueNode) IsBool() bool

+ func (node *GoValueNode) IsInteger() bool

+ func (node *GoValueNode) IsMap() bool

+ func (node *GoValueNode) IsObject() bool

+ func (node *GoValueNode) IsReal() bool

+ func (node *GoValueNode) IsString() bool

+ func (node *GoValueNode) IsTime() bool

+ func (node *GoValueNode) Length() (int, error)

+ func (node *GoValueNode) Parent() ValueNode

+ func (node *GoValueNode) SetArrayValueAt(index int, value reflect.Value) (err error)

+ func (node *GoValueNode) SetMapValueAt(index, newValue reflect.Value) (err error)

+ func (node *GoValueNode) SetObjectValueByField(field string, newValue reflect.Value) (err error)

+ func (node *GoValueNode) Value() reflect.Value

+ type ValueNode interface

+ AppendValue func(value []reflect.Value) error

+ CallFunction func(funcName string, args ...reflect.Value) (reflect.Value, error)

+ ContinueWithValue func(value reflect.Value, identifiedAs string) ValueNode

+ GetArrayType func() (reflect.Type, error)

+ GetArrayValueAt func(index int) (reflect.Value, error)

+ GetChildNodeByField func(field string) (ValueNode, error)

+ GetChildNodeByIndex func(index int) (ValueNode, error)

+ GetChildNodeBySelector func(index reflect.Value) (ValueNode, error)

+ GetMapValueAt func(index reflect.Value) (reflect.Value, error)

+ GetObjectTypeByField func(field string) (reflect.Type, error)

+ GetObjectValueByField func(field string) (reflect.Value, error)

+ GetType func() (reflect.Type, error)

+ GetValue func() (reflect.Value, error)

+ HasParent func() bool

+ IdentifiedAs func() string

+ IsArray func() bool

+ IsBool func() bool

+ IsInteger func() bool

+ IsMap func() bool

+ IsObject func() bool

+ IsReal func() bool

+ IsString func() bool

+ IsTime func() bool

+ Length func() (int, error)

+ Parent func() ValueNode

+ SetArrayValueAt func(index int, value reflect.Value) error

+ SetMapValueAt func(index, newValue reflect.Value) error

+ SetObjectValueByField func(field string, newValue reflect.Value) error

+ Value func() reflect.Value

+ func NewGoValueNode(value reflect.Value, identifiedAs string) ValueNode

Dec 27, 2019

Changes in this version

+ type AlphaNode interface

+ EqualsTo func(other AlphaNode) bool

type ArgumentHolder

+ func (ah *ArgumentHolder) EqualsTo(that AlphaNode) bool

type Constant

+ func (cons *Constant) EqualsTo(that AlphaNode) bool

type Expression

+ func (expr *Expression) EqualsTo(that AlphaNode) bool

type ExpressionAtom

+ func (exprAtm *ExpressionAtom) EqualsTo(that AlphaNode) bool

+ func (exprAtm *ExpressionAtom) Reset()

type FunctionArgument

+ func (funcArg *FunctionArgument) EqualsTo(that AlphaNode) bool

type FunctionCall

+ func (funcCall *FunctionCall) EqualsTo(that AlphaNode) bool

type KnowledgeBase

+ Name string

+ RuleContext *RuleContext

+ Version string

+ func (k *KnowledgeBase) RuleContextReset()

type MethodCall

+ func (methCall *MethodCall) EqualsTo(that AlphaNode) bool

type Predicate

+ func (prdct *Predicate) EqualsTo(that AlphaNode) bool

+ type RuleContext struct

+ ExpressionAtoms []*ExpressionAtom

+ func NewRuleContext() *RuleContext

+ func (rc *RuleContext) Add(ea *ExpressionAtom) *ExpressionAtom

+ func (rc *RuleContext) Contains(ea *ExpressionAtom) bool

+ func (rc *RuleContext) Reset()

Dec 15, 2019

Changes in this version

+ const TimeTypeString

+ var ComparisonOperatorEQ = ComparisonOperator("==")

+ var ComparisonOperatorGT = ComparisonOperator(">")

+ var ComparisonOperatorGTE = ComparisonOperator(">=")

+ var ComparisonOperatorLT = ComparisonOperator("<")

+ var ComparisonOperatorLTE = ComparisonOperator("<=")

+ var ComparisonOperatorNEQ = ComparisonOperator("!=")

+ var LogicalOperatorAnd = LogicalOperator(1)

+ var LogicalOperatorOr = LogicalOperator(2)

+ var MathOperatorDiv = MathOperator(2)

+ var MathOperatorMinus = MathOperator(4)

+ var MathOperatorMul = MathOperator(1)

+ var MathOperatorPlus = MathOperator(3)

+ type ArgumentHolder struct

+ Constant *Constant

+ Expression *Expression

+ FunctionCall *FunctionCall

+ MethodCall *MethodCall

+ Variable string

+ func (ah *ArgumentHolder) Evaluate() (reflect.Value, error)

+ func (ah *ArgumentHolder) Initialize(knowledgeContext *context.KnowledgeContext, ruleCtx *context.RuleContext, ...)

+ type AssignExpression struct

+ Assignment *Assignment

+ FunctionCall *FunctionCall

+ MethodCall *MethodCall

+ func (ae *AssignExpression) AcceptFunctionCall(funcCall *FunctionCall) error

+ func (ae *AssignExpression) AcceptMethodCall(methodCall *MethodCall) error

+ func (ae *AssignExpression) Evaluate() (reflect.Value, error)

+ func (ae *AssignExpression) Initialize(knowledgeContext *context.KnowledgeContext, ruleCtx *context.RuleContext, ...)

+ type AssignExpressions struct

+ ExpressionList []*AssignExpression

+ func (ae *AssignExpressions) Evaluate() (reflect.Value, error)

+ func (ae *AssignExpressions) Initialize(knowledgeContext *context.KnowledgeContext, ruleCtx *context.RuleContext, ...)

+ type Assignment struct

+ Expression *Expression

+ Variable string

+ func (assign *Assignment) AcceptExpression(expression *Expression) error

+ func (assign *Assignment) AcceptVariable(name string) error

+ func (assign *Assignment) Evaluate() (reflect.Value, error)

+ func (assign *Assignment) Initialize(knowledgeContext *context.KnowledgeContext, ruleCtx *context.RuleContext, ...)

+ type ComparisonOperator string

+ type Constant struct

+ ConstantValue reflect.Value

+ func (cons *Constant) AcceptDecimal(val int64) error

+ func (cons *Constant) Evaluate() (reflect.Value, error)

+ func (cons *Constant) Initialize(knowledgeContext *context.KnowledgeContext, ruleCtx *context.RuleContext, ...)

+ type ConstantHolder interface

+ AcceptConstant func(cons *Constant) error

+ type DecimalHolder interface

+ AcceptDecimal func(val int64) error

+ type Evaluator interface

+ Evaluate func() (reflect.Value, error)

+ type Expression struct

+ LeftExpression *Expression

+ LogicalOperator LogicalOperator

+ Predicate *Predicate

+ RightExpression *Expression

+ func (expr *Expression) AcceptExpression(expression *Expression) error

+ func (expr *Expression) Evaluate() (reflect.Value, error)

+ func (expr *Expression) Initialize(knowledgeContext *context.KnowledgeContext, ruleCtx *context.RuleContext, ...)

+ type ExpressionAtom struct

+ Constant *Constant

+ ExpressionAtomLeft *ExpressionAtom

+ ExpressionAtomRight *ExpressionAtom

+ FunctionCall *FunctionCall

+ MathOperator MathOperator

+ MethodCall *MethodCall

+ Text string

+ Variable string

+ func (exprAtm *ExpressionAtom) AcceptConstant(cons *Constant) error

+ func (exprAtm *ExpressionAtom) AcceptExpressionAtom(exprAtom *ExpressionAtom) error

+ func (exprAtm *ExpressionAtom) AcceptFunctionCall(funcCall *FunctionCall) error

+ func (exprAtm *ExpressionAtom) AcceptMethodCall(methodCall *MethodCall) error

+ func (exprAtm *ExpressionAtom) AcceptVariable(name string) error

+ func (exprAtm *ExpressionAtom) Evaluate() (reflect.Value, error)

+ func (exprAtm *ExpressionAtom) Initialize(knowledgeContext *context.KnowledgeContext, ruleCtx *context.RuleContext, ...)

+ type ExpressionAtomHolder interface

+ AcceptExpressionAtom func(exprAtom *ExpressionAtom) error

+ type ExpressionHolder interface

+ AcceptExpression func(expression *Expression) error

+ type FunctionArgument struct

+ Arguments []*ArgumentHolder

+ func (funcArg *FunctionArgument) AcceptConstant(cons *Constant) error

+ func (funcArg *FunctionArgument) AcceptExpression(expression *Expression) error

+ func (funcArg *FunctionArgument) AcceptFunctionCall(funcCall *FunctionCall) error

+ func (funcArg *FunctionArgument) AcceptMethodCall(methodCall *MethodCall) error

+ func (funcArg *FunctionArgument) AcceptVariable(name string) error

+ func (funcArg *FunctionArgument) EvaluateArguments() ([]reflect.Value, error)

+ func (funcArg *FunctionArgument) Initialize(knowledgeContext *context.KnowledgeContext, ruleCtx *context.RuleContext, ...)

+ type FunctionArgumentHolder interface

+ AcceptFunctionArgument func(funcArg *FunctionArgument) error

+ type FunctionCall struct

+ FunctionArguments *FunctionArgument

+ FunctionName string

+ func (funcCall *FunctionCall) AcceptFunctionArgument(funcArg *FunctionArgument) error

+ func (funcCall *FunctionCall) Evaluate() (reflect.Value, error)

+ func (funcCall *FunctionCall) Initialize(knowledgeContext *context.KnowledgeContext, ruleCtx *context.RuleContext, ...)

+ type FunctionCallHolder interface

+ AcceptFunctionCall func(funcCall *FunctionCall) error

+ type GraphInitializer interface

+ Initialize func(knowledgeContext *context.KnowledgeContext, ruleCtx *context.RuleContext, ...)

+ type GruleFunction struct

+ Knowledge *KnowledgeBase

+ func (gf *GruleFunction) GetTimeDay(time time.Time) int

+ func (gf *GruleFunction) GetTimeHour(time time.Time) int

+ func (gf *GruleFunction) GetTimeMinute(time time.Time) int

+ func (gf *GruleFunction) GetTimeMonth(time time.Time) int

+ func (gf *GruleFunction) GetTimeSecond(time time.Time) int

+ func (gf *GruleFunction) GetTimeYear(time time.Time) int

+ func (gf *GruleFunction) IsNil(i interface{}) bool

+ func (gf *GruleFunction) IsTimeAfter(time, after time.Time) bool

+ func (gf *GruleFunction) IsTimeBefore(time, before time.Time) bool

+ func (gf *GruleFunction) IsZero(i interface{}) bool

+ func (gf *GruleFunction) Log(text string)

+ func (gf *GruleFunction) MakeTime(year, month, day, hour, minute, second int64) time.Time

+ func (gf *GruleFunction) Now() time.Time

+ func (gf *GruleFunction) Retract(ruleName string)

+ func (gf *GruleFunction) TimeFormat(time time.Time, layout string) string

+ type KnowledgeBase struct

+ RuleEntries map[string]*RuleEntry

+ func NewKnowledgeBase() *KnowledgeBase

+ func (k *KnowledgeBase) Reset()

+ func (k *KnowledgeBase) Retract(ruleEntryName string)

+ type LogicalOperator int

+ type MathOperator int

+ type MethodCall struct

+ MethodArguments *FunctionArgument

+ MethodName string

+ func (methCall *MethodCall) AcceptFunctionArgument(funcArg *FunctionArgument) error

+ func (methCall *MethodCall) Evaluate() (reflect.Value, error)

+ func (methCall *MethodCall) Initialize(knowledgeContext *context.KnowledgeContext, ruleCtx *context.RuleContext, ...)

+ type MethodCallHolder interface

+ AcceptMethodCall func(methodCall *MethodCall) error

+ type Predicate struct

+ ComparisonOperator ComparisonOperator

+ ExpressionAtomLeft *ExpressionAtom

+ ExpressionAtomRight *ExpressionAtom

+ func (prdct *Predicate) AcceptExpressionAtom(exprAtom *ExpressionAtom) error

+ func (prdct *Predicate) Evaluate() (reflect.Value, error)

+ func (prdct *Predicate) Initialize(knowledgeContext *context.KnowledgeContext, ruleCtx *context.RuleContext, ...)

+ type RuleEntry struct

+ Retracted bool

+ RuleDescription string

+ RuleName string

+ Salience int64

+ ThenScope *ThenScope

+ WhenScope *WhenScope

+ func (entry *RuleEntry) AcceptDecimal(val int64) error

+ func (entry *RuleEntry) CanExecute() (bool, error)

+ func (entry *RuleEntry) Execute() error

+ func (entry *RuleEntry) Initialize(knowledgeContext *context.KnowledgeContext, ruleCtx *context.RuleContext, ...)

+ type ThenScope struct

+ AssignExpressions *AssignExpressions

+ func (then *ThenScope) Execute() error

+ func (then *ThenScope) Initialize(knowledgeContext *context.KnowledgeContext, ruleCtx *context.RuleContext, ...)

+ type VariableHolder interface

+ AcceptVariable func(name string) error

+ type WhenScope struct

+ Expression *Expression

+ func (when *WhenScope) AcceptExpression(expression *Expression) error

+ func (when *WhenScope) ExecuteWhen() (bool, error)

+ func (when *WhenScope) Initialize(knowledgeContext *context.KnowledgeContext, ruleCtx *context.RuleContext, ...)