filters

README

target-filter

target filter

Build

• 

a filter tool for customer's filter functions

Usage

repo functions

// FilterRepo filter repo
type FilterRepo interface {
	// Set filter timeout: is second, and must be above zero.
	SetFilterTimeout(int) error
	// add a filter function : CompareFunc
	AddCompareFunc(name string, cf CompareFunc)
	// remove a compare funcation by name
	RemoveCompareFunc(name string)
	// get filter function
	GetCompareFunc(name string) CompareFunc
	// compare input values and filter values
	Compare(filter *FilterParams, input, target FilterValues) (bool, error)
}

type FilterParams struct {
	// filter names
	Names []string
	// compare type: Sequence (0) or Consistent (1)
	Type  CompareType
}

new a filter

	manager := filter.New()
	manager.AddFilterFunc(filterName, filterNameFunction)

do sequence filter

fParams := &filter.FilterParams{Names: []string{"filterName"}
manager.Compare(fParams, nil, nil)

Or

fParams := &filter.FilterParams{Type: filter.CompareTypeSequence, Names: []string{"filterName"}
manager.Compare(fParams, nil, nil)

do consistent filter

fParams := &filter.FilterParams{Type: filter.CompareTypeConsistent, Names: []string{"filterName"}
manager.Compare(fParams, nil, nil)

Get more

test_file

Documentation

Index

• Constants
• Variables
• func CompareEqualsFunc(input, target FilterValues) (filtered bool, err error)
• type CompareFunc
• type CompareType
• type FilterParams
• type FilterRepo
  • func New() FilterRepo
• type FilterValues

Constants

const (
	EqualFunctionName = "go-trellis::filters::equals"
)

defaults function names

Variables

var (
	ErrInvalidFilterName        = errors.TN(namespace, 1000, "invalid filter name")
	ErrFilterFunctionEqualNil   = errors.TN(namespace, 1001, "filter function should not be nil")
	ErrNotSupportedFilterType   = errors.TN(namespace, 1002, "filter type not supported")
	ErrNotExistsInputParams     = errors.TN(namespace, 1003, "not exists input params")
	ErrNotExistsTargetParams    = errors.TN(namespace, 1004, "not exists target params")
	ErrFailedExecFilterFunction = errors.TN(namespace, 1005, "failed exec filter function: {{.err}}")
	ErrFailedExecTimeout        = errors.TN(namespace, 1006, "exec filter function timeout")
	ErrTimeoutMustAboveZero     = errors.TN(namespace, 1007, "set timeout must above zero")
	ErrUnknownCompareType       = errors.TN(namespace, 1008, "unknown compare type")
)

errors

Functions

func CompareEqualsFunc

func CompareEqualsFunc(input, target FilterValues) (filtered bool, err error)

CompareEqualsFunc compare values must equal

Types

type CompareFunc

type CompareFunc func(input, target FilterValues) (filtered bool, err error)

CompareFunc is the function you want to compare input values with target values Input Values is the k:v maps with input values Target Values is the k:v maps with filter values return bool is filtered return error if compare function has internal error you can write you campare functions like FilterFunc, then manager.AddFilterFunc(name, filterFunc)

type CompareType

type CompareType int

CompareType compare type

const (
	CompareTypeSequence CompareType = iota
	CompareTypeConsistent
)

CompareType defines

type FilterParams

type FilterParams struct {
	Names []string
	Type  CompareType
}

FilterParams filter params

type FilterRepo

type FilterRepo interface {
	// Set compare timeout: must be above zero.
	SetCompareTimeout(time.Duration) error
	// add a compare function : CompareFunc
	AddCompareFunc(name string, cf CompareFunc)
	// remove a compare funcation by name
	RemoveCompareFunc(name string)
	// get compare function
	GetCompareFunc(name string) CompareFunc
	// compare input values and filter values
	Compare(filter *FilterParams, input, target FilterValues) (bool, error)
}

FilterRepo filter repo

func New

func New() FilterRepo

New generate an new target filter

type FilterValues

type FilterValues map[string]interface{}

FilterValues type map[string]interface{}