How to use Filter method of filter Package

...7	"sort"8)9// ----------------------------------------------------------------------------10// Export filtering11// exportFilter is a special filter function to extract exported nodes.12func exportFilter(name string) bool {13	return IsExported(name)14}15// FileExports trims the AST for a Go source file in place such that16// only exported nodes remain: all top-level identifiers which are not exported17// and their associated information (such as type, initial value, or function18// body) are removed. Non-exported fields and methods of exported types are19// stripped. The File.Comments list is not changed.20//21// FileExports returns true if there are exported declarations;22// it returns false otherwise.23//24func FileExports(src *File) bool {25	return filterFile(src, exportFilter, true)26}27// PackageExports trims the AST for a Go package in place such that28// only exported nodes remain. The pkg.Files list is not changed, so that29// file names and top-level package comments don't get lost.30//31// PackageExports returns true if there are exported declarations;32// it returns false otherwise.33//34func PackageExports(pkg *Package) bool {35	return filterPackage(pkg, exportFilter, true)36}37// ----------------------------------------------------------------------------38// General filtering39type Filter func(string) bool40func filterIdentList(list []*Ident, f Filter) []*Ident {41	j := 042	for _, x := range list {43		if f(x.Name) {44			list[j] = x45			j++46		}47	}48	return list[0:j]49}50// fieldName assumes that x is the type of an anonymous field and51// returns the corresponding field name. If x is not an acceptable52// anonymous field, the result is nil.53//54func fieldName(x Expr) *Ident {55	switch t := x.(type) {56	case *Ident:57		return t58	case *SelectorExpr:59		if _, ok := t.X.(*Ident); ok {60			return t.Sel61		}62	case *StarExpr:63		return fieldName(t.X)64	}65	return nil66}67func filterFieldList(fields *FieldList, filter Filter, export bool) (removedFields bool) {68	if fields == nil {69		return false70	}71	list := fields.List72	j := 073	for _, f := range list {74		keepField := false75		if len(f.Names) == 0 {76			// anonymous field77			name := fieldName(f.Type)78			keepField = name != nil && filter(name.Name)79		} else {80			n := len(f.Names)81			f.Names = filterIdentList(f.Names, filter)82			if len(f.Names) < n {83				removedFields = true84			}85			keepField = len(f.Names) > 086		}87		if keepField {88			if export {89				filterType(f.Type, filter, export)90			}91			list[j] = f92			j++93		}94	}95	if j < len(list) {96		removedFields = true97	}98	fields.List = list[0:j]99	return100}101func filterParamList(fields *FieldList, filter Filter, export bool) bool {102	if fields == nil {103		return false104	}105	var b bool106	for _, f := range fields.List {107		if filterType(f.Type, filter, export) {108			b = true109		}110	}111	return b112}113func filterType(typ Expr, f Filter, export bool) bool {114	switch t := typ.(type) {115	case *Ident:116		return f(t.Name)117	case *ParenExpr:118		return filterType(t.X, f, export)119	case *ArrayType:120		return filterType(t.Elt, f, export)121	case *StructType:122		if filterFieldList(t.Fields, f, export) {123			t.Incomplete = true124		}125		return len(t.Fields.List) > 0126	case *FuncType:127		b1 := filterParamList(t.Params, f, export)128		b2 := filterParamList(t.Results, f, export)129		return b1 || b2130	case *InterfaceType:131		if filterFieldList(t.Methods, f, export) {132			t.Incomplete = true133		}134		return len(t.Methods.List) > 0135	case *MapType:136		b1 := filterType(t.Key, f, export)137		b2 := filterType(t.Value, f, export)138		return b1 || b2139	case *ChanType:140		return filterType(t.Value, f, export)141	}142	return false143}144func filterSpec(spec Spec, f Filter, export bool) bool {145	switch s := spec.(type) {146	case *ValueSpec:147		s.Names = filterIdentList(s.Names, f)148		if len(s.Names) > 0 {149			if export {150				filterType(s.Type, f, export)151			}152			return true153		}154	case *TypeSpec:155		if f(s.Name.Name) {156			if export {157				filterType(s.Type, f, export)158			}159			return true160		}161		if !export {162			// For general filtering (not just exports),163			// filter type even if name is not filtered164			// out.165			// If the type contains filtered elements,166			// keep the declaration.167			return filterType(s.Type, f, export)168		}169	}170	return false171}172func filterSpecList(list []Spec, f Filter, export bool) []Spec {173	j := 0174	for _, s := range list {175		if filterSpec(s, f, export) {176			list[j] = s177			j++178		}179	}180	return list[0:j]181}182// FilterDecl trims the AST for a Go declaration in place by removing183// all names (including struct field and interface method names, but184// not from parameter lists) that don't pass through the filter f.185//186// FilterDecl returns true if there are any declared names left after187// filtering; it returns false otherwise.188//189func FilterDecl(decl Decl, f Filter) bool {190	return filterDecl(decl, f, false)191}192func filterDecl(decl Decl, f Filter, export bool) bool {193	switch d := decl.(type) {194	case *GenDecl:195		d.Specs = filterSpecList(d.Specs, f, export)196		return len(d.Specs) > 0197	case *FuncDecl:198		return f(d.Name.Name)199	}200	return false201}202// FilterFile trims the AST for a Go file in place by removing all203// names from top-level declarations (including struct field and204// interface method names, but not from parameter lists) that don't205// pass through the filter f. If the declaration is empty afterwards,206// the declaration is removed from the AST. The File.Comments list207// is not changed.208//209// FilterFile returns true if there are any top-level declarations210// left after filtering; it returns false otherwise.211//212func FilterFile(src *File, f Filter) bool {213	return filterFile(src, f, false)214}215func filterFile(src *File, f Filter, export bool) bool {216	j := 0217	for _, d := range src.Decls {218		if filterDecl(d, f, export) {219			src.Decls[j] = d220			j++221		}222	}223	src.Decls = src.Decls[0:j]224	return j > 0225}226// FilterPackage trims the AST for a Go package in place by removing227// all names from top-level declarations (including struct field and228// interface method names, but not from parameter lists) that don't229// pass through the filter f. If the declaration is empty afterwards,230// the declaration is removed from the AST. The pkg.Files list is not231// changed, so that file names and top-level package comments don't get232// lost.233//234// FilterPackage returns true if there are any top-level declarations235// left after filtering; it returns false otherwise.236//237func FilterPackage(pkg *Package, f Filter) bool {238	return filterPackage(pkg, f, false)239}240func filterPackage(pkg *Package, f Filter, export bool) bool {241	hasDecls := false242	for _, src := range pkg.Files {243		if filterFile(src, f, export) {244			hasDecls = true245		}246	}247	return hasDecls248}249// ----------------------------------------------------------------------------250// Merging of package files251// The MergeMode flags control the behavior of MergePackageFiles.252type MergeMode uint253const (254	// If set, duplicate function declarations are excluded.255	FilterFuncDuplicates MergeMode = 1 << iota256	// If set, comments that are not associated with a specific257	// AST node (as Doc or Comment) are excluded.258	FilterUnassociatedComments259	// If set, duplicate import declarations are excluded.260	FilterImportDuplicates261)262// nameOf returns the function (foo) or method name (foo.bar) for263// the given function declaration. If the AST is incorrect for the264// receiver, it assumes a function instead.265//266func nameOf(f *FuncDecl) string {267	if r := f.Recv; r != nil && len(r.List) == 1 {268		// looks like a correct receiver declaration269		t := r.List[0].Type270		// dereference pointer receiver types271		if p, _ := t.(*StarExpr); p != nil {272			t = p.X273		}274		// the receiver type must be a type name275		if p, _ := t.(*Ident); p != nil {276			return p.Name + "." + f.Name.Name277		}278		// otherwise assume a function instead279	}280	return f.Name.Name281}282// separator is an empty //-style comment that is interspersed between283// different comment groups when they are concatenated into a single group284//285var separator = &Comment{token.NoPos, "//"}286// MergePackageFiles creates a file AST by merging the ASTs of the287// files belonging to a package. The mode flags control merging behavior.288//289func MergePackageFiles(pkg *Package, mode MergeMode) *File {290	// Count the number of package docs, comments and declarations across291	// all package files. Also, compute sorted list of filenames, so that292	// subsequent iterations can always iterate in the same order.293	ndocs := 0294	ncomments := 0295	ndecls := 0296	filenames := make([]string, len(pkg.Files))297	i := 0298	for filename, f := range pkg.Files {299		filenames[i] = filename300		i++301		if f.Doc != nil {302			ndocs += len(f.Doc.List) + 1 // +1 for separator303		}304		ncomments += len(f.Comments)305		ndecls += len(f.Decls)306	}307	sort.Strings(filenames)308	// Collect package comments from all package files into a single309	// CommentGroup - the collected package documentation. In general310	// there should be only one file with a package comment; but it's311	// better to collect extra comments than drop them on the floor.312	var doc *CommentGroup313	var pos token.Pos314	if ndocs > 0 {315		list := make([]*Comment, ndocs-1) // -1: no separator before first group316		i := 0317		for _, filename := range filenames {318			f := pkg.Files[filename]319			if f.Doc != nil {320				if i > 0 {321					// not the first group - add separator322					list[i] = separator323					i++324				}325				for _, c := range f.Doc.List {326					list[i] = c327					i++328				}329				if f.Package > pos {330					// Keep the maximum package clause position as331					// position for the package clause of the merged332					// files.333					pos = f.Package334				}335			}336		}337		doc = &CommentGroup{list}338	}339	// Collect declarations from all package files.340	var decls []Decl341	if ndecls > 0 {342		decls = make([]Decl, ndecls)343		funcs := make(map[string]int) // map of func name -> decls index344		i := 0                        // current index345		n := 0                        // number of filtered entries346		for _, filename := range filenames {347			f := pkg.Files[filename]348			for _, d := range f.Decls {349				if mode&FilterFuncDuplicates != 0 {350					// A language entity may be declared multiple351					// times in different package files; only at352					// build time declarations must be unique.353					// For now, exclude multiple declarations of354					// functions - keep the one with documentation.355					//356					// TODO(gri): Expand this filtering to other357					//            entities (const, type, vars) if358					//            multiple declarations are common.359					if f, isFun := d.(*FuncDecl); isFun {360						name := nameOf(f)361						if j, exists := funcs[name]; exists {362							// function declared already363							if decls[j] != nil && decls[j].(*FuncDecl).Doc == nil {364								// existing declaration has no documentation;365								// ignore the existing declaration366								decls[j] = nil367							} else {368								// ignore the new declaration369								d = nil370							}371							n++ // filtered an entry372						} else {373							funcs[name] = i374						}375					}376				}377				decls[i] = d378				i++379			}380		}381		// Eliminate nil entries from the decls list if entries were382		// filtered. We do this using a 2nd pass in order to not disturb383		// the original declaration order in the source (otherwise, this384		// would also invalidate the monotonically increasing position385		// info within a single file).386		if n > 0 {387			i = 0388			for _, d := range decls {389				if d != nil {390					decls[i] = d391					i++392				}393			}394			decls = decls[0:i]395		}396	}397	// Collect import specs from all package files.398	var imports []*ImportSpec399	if mode&FilterImportDuplicates != 0 {400		seen := make(map[string]bool)401		for _, filename := range filenames {402			f := pkg.Files[filename]403			for _, imp := range f.Imports {404				if path := imp.Path.Value; !seen[path] {405					// TODO: consider handling cases where:406					// - 2 imports exist with the same import path but407					//   have different local names (one should probably408					//   keep both of them)409					// - 2 imports exist but only one has a comment410					// - 2 imports exist and they both have (possibly411					//   different) comments412					imports = append(imports, imp)413					seen[path] = true414				}415			}416		}417	} else {418		for _, f := range pkg.Files {419			imports = append(imports, f.Imports...)420		}421	}422	// Collect comments from all package files.423	var comments []*CommentGroup424	if mode&FilterUnassociatedComments == 0 {425		comments = make([]*CommentGroup, ncomments)426		i := 0427		for _, f := range pkg.Files {428			i += copy(comments[i:], f.Comments)429		}430	}431	// TODO(gri) need to compute unresolved identifiers!432	return &File{doc, pos, NewIdent(pkg.Name), decls, pkg.Scope, imports, nil, comments}433}...

...69			{{0x21, 0x41, 0x7d, 0xf9}},70		},71	},72}73func TestFilterTopicsCreation(t *testing.T) {74	// Check full filter creation75	for i, tt := range filterTopicsCreationTests {76		// Check the textual creation77		filter := NewFilterTopicsFromStrings(tt.topics...)78		if len(filter) != len(tt.topics) {79			t.Errorf("test %d: condition count mismatch: have %v, want %v", i, len(filter), len(tt.topics))80			continue81		}82		for j, condition := range filter {83			if len(condition) != len(tt.filter[j]) {84				t.Errorf("test %d, condition %d: size mismatch: have %v, want %v", i, j, len(condition), len(tt.filter[j]))85				continue86			}87			for k := 0; k < len(condition); k++ {88				if !bytes.Equal(condition[k][:], tt.filter[j][k][:]) {89					t.Errorf("test %d, condition %d, segment %d: filter mismatch: have 0x%x, want 0x%x", i, j, k, condition[k], tt.filter[j][k])90				}91			}92		}93		// Check the binary creation94		binary := make([][][]byte, len(tt.topics))95		for j, condition := range tt.topics {96			binary[j] = make([][]byte, len(condition))97			for k, segment := range condition {98				binary[j][k] = []byte(segment)99			}100		}101		filter = NewFilterTopics(binary...)102		if len(filter) != len(tt.topics) {103			t.Errorf("test %d: condition count mismatch: have %v, want %v", i, len(filter), len(tt.topics))104			continue105		}106		for j, condition := range filter {107			if len(condition) != len(tt.filter[j]) {108				t.Errorf("test %d, condition %d: size mismatch: have %v, want %v", i, j, len(condition), len(tt.filter[j]))109				continue110			}111			for k := 0; k < len(condition); k++ {112				if !bytes.Equal(condition[k][:], tt.filter[j][k][:]) {113					t.Errorf("test %d, condition %d, segment %d: filter mismatch: have 0x%x, want 0x%x", i, j, k, condition[k], tt.filter[j][k])114				}115			}116		}117	}118	// Check flat filter creation119	for i, tt := range filterTopicsCreationFlatTests {120		// Check the textual creation121		filter := NewFilterTopicsFromStringsFlat(tt.topics...)122		if len(filter) != len(tt.topics) {123			t.Errorf("test %d: condition count mismatch: have %v, want %v", i, len(filter), len(tt.topics))124			continue125		}126		for j, condition := range filter {127			if len(condition) != len(tt.filter[j]) {128				t.Errorf("test %d, condition %d: size mismatch: have %v, want %v", i, j, len(condition), len(tt.filter[j]))129				continue130			}131			for k := 0; k < len(condition); k++ {132				if !bytes.Equal(condition[k][:], tt.filter[j][k][:]) {133					t.Errorf("test %d, condition %d, segment %d: filter mismatch: have 0x%x, want 0x%x", i, j, k, condition[k], tt.filter[j][k])134				}135			}136		}137		// Check the binary creation138		binary := make([][]byte, len(tt.topics))139		for j, topic := range tt.topics {140			binary[j] = []byte(topic)141		}142		filter = NewFilterTopicsFlat(binary...)143		if len(filter) != len(tt.topics) {144			t.Errorf("test %d: condition count mismatch: have %v, want %v", i, len(filter), len(tt.topics))145			continue146		}147		for j, condition := range filter {148			if len(condition) != len(tt.filter[j]) {149				t.Errorf("test %d, condition %d: size mismatch: have %v, want %v", i, j, len(condition), len(tt.filter[j]))150				continue151			}152			for k := 0; k < len(condition); k++ {153				if !bytes.Equal(condition[k][:], tt.filter[j][k][:]) {154					t.Errorf("test %d, condition %d, segment %d: filter mismatch: have 0x%x, want 0x%x", i, j, k, condition[k], tt.filter[j][k])155				}156			}157		}158	}159}160var filterCompareTests = []struct {161	matcher filterer162	message filterer163	match   bool164}{165	{ // Wild-card filter matching anything166		matcher: filterer{to: "", from: "", matcher: newTopicMatcher()},167		message: filterer{to: "to", from: "from", matcher: newTopicMatcher(NewFilterTopicsFromStringsFlat("topic")...)},168		match:   true,169	},170	{ // Filter matching the to field171		matcher: filterer{to: "to", from: "", matcher: newTopicMatcher()},172		message: filterer{to: "to", from: "from", matcher: newTopicMatcher(NewFilterTopicsFromStringsFlat("topic")...)},173		match:   true,174	},175	{ // Filter rejecting the to field176		matcher: filterer{to: "to", from: "", matcher: newTopicMatcher()},177		message: filterer{to: "", from: "from", matcher: newTopicMatcher(NewFilterTopicsFromStringsFlat("topic")...)},178		match:   false,179	},180	{ // Filter matching the from field181		matcher: filterer{to: "", from: "from", matcher: newTopicMatcher()},182		message: filterer{to: "to", from: "from", matcher: newTopicMatcher(NewFilterTopicsFromStringsFlat("topic")...)},183		match:   true,184	},185	{ // Filter rejecting the from field186		matcher: filterer{to: "", from: "from", matcher: newTopicMatcher()},187		message: filterer{to: "to", from: "", matcher: newTopicMatcher(NewFilterTopicsFromStringsFlat("topic")...)},188		match:   false,189	},190	{ // Filter matching the topic field191		matcher: filterer{to: "", from: "from", matcher: newTopicMatcher(NewFilterTopicsFromStringsFlat("topic")...)},192		message: filterer{to: "to", from: "from", matcher: newTopicMatcher(NewFilterTopicsFromStringsFlat("topic")...)},193		match:   true,194	},195	{ // Filter rejecting the topic field196		matcher: filterer{to: "", from: "", matcher: newTopicMatcher(NewFilterTopicsFromStringsFlat("topic")...)},197		message: filterer{to: "to", from: "from", matcher: newTopicMatcher()},198		match:   false,199	},200}201func TestFilterCompare(t *testing.T) {202	for i, tt := range filterCompareTests {203		if match := tt.matcher.Compare(tt.message); match != tt.match {204			t.Errorf("test %d: match mismatch: have %v, want %v", i, match, tt.match)205		}206	}207}...

1package godruid2type Filter struct {3	Type      string      `json:"type"`4	Dimension string      `json:"dimension,omitempty"`5	Value     interface{} `json:"value,omitempty"`6	Pattern   string      `json:"pattern,omitempty"`7	Function  string      `json:"function,omitempty"`8	Field     *Filter     `json:"field,omitempty"`9	Fields    []*Filter   `json:"fields,omitempty"`10}11func FilterSelector(dimension string, value interface{}) *Filter {12	return &Filter{13		Type:      "selector",14		Dimension: dimension,15		Value:     value,16	}17}18func FilterRegex(dimension, pattern string) *Filter {19	return &Filter{20		Type:      "regex",21		Dimension: dimension,22		Pattern:   pattern,23	}24}25func FilterJavaScript(dimension, function string) *Filter {26	return &Filter{27		Type:      "javascript",28		Dimension: dimension,29		Function:  function,30	}31}32func FilterAnd(filters ...*Filter) *Filter {33	return joinFilters(filters, "and")34}35func FilterOr(filters ...*Filter) *Filter {36	return joinFilters(filters, "or")37}38func FilterNot(filter *Filter) *Filter {39	return &Filter{40		Type:  "not",41		Field: filter,42	}43}44func joinFilters(filters []*Filter, connector string) *Filter {45	// Remove null filters.46	p := 047	for _, f := range filters {48		if f != nil {49			filters[p] = f50			p++51		}52	}53	filters = filters[0:p]54	fLen := len(filters)55	if fLen == 0 {56		return nil57	}58	if fLen == 1 {59		return filters[0]60	}61	return &Filter{62		Type:   connector,63		Fields: filters,64	}65}...

1import (2func main() {3	slice := []int{1, 2, 3, 4, 5, 6, 7, 8}4	fmt.Println("slice before filter:", slice)5	filteredSlice := filter.Filter(slice, func(i int) bool {6	})7	fmt.Println("slice after filter:", filteredSlice)8}

1import (2func main() {3	s := []int{1, 2, 3, 4, 5, 6, 7, 8}4	fmt.Println("slice = ", s)5	fmt.Println("even numbers in slice = ", filter.Even(s))6	fmt.Println("odd numbers in slice = ", filter.Odd(s))7}

1import (2func main() {3	var a []int = []int{1, 2, 3, 4, 5, 6, 7, 8, 9}4	fmt.Println("The original slice is: ", a)5	var b []int = filter.Filter(a, func(x int) bool {6	})7	fmt.Println("The filtered slice is: ", b)8}

1import (2func main() {3	a = []int{1, 2, 3, 4, 5, 6}4	fmt.Println("Original array is:", a)5	fmt.Println("Even numbers are:", filter.Filter(a, filter.IsEven))6	fmt.Println("Odd numbers are:", filter.Filter(a, filter.IsOdd))7}

1import (2func main() {3	slice := []int{1, 2, 3, 4}4	fmt.Println("slice = ", slice)5	fmt.Println("Odd elements of slice = ", Filter.Odd(slice))6	fmt.Println("Even elements of slice = ", Filter.Even(slice))7}

1import (2func main() {3	var a []int = []int{1, 2, 3, 4, 5}4	fmt.Println("Before Filtering: ", a)5	filter.Filter(a, func(n int) bool {6	})7	fmt.Println("After Filtering: ", a)8}

1import (2func main() {3	xs := []int{1, 2, 3, 4}4	fmt.Println(filter.Filter(xs, func(n int) bool {5	}))6}

1import (2func main() {3	slice := []string{"hello", "", "how", "", "are", "", "you"}4	f := filter.New(slice)5	f.Filter(func(str string) bool {6	})7	fmt.Println(f)8}

1import (2func main() {3	fmt.Println("Enter string")4	fmt.Scanln(&str)5	fmt.Println(f.Filter(str))6}

1import (2func main() {3	slice := []string{"Hello", "", "World", "Program"}4	slice = filter.Filter(slice, func(s string) bool {5		return len(s) > 06	})7	fmt.Println(slice)8}