gxset

Documentation

Overview

refs: https://github.com/deckarep/golang-set 20170413, branch master, latest version v1.6

refs: https://github.com/deckarep/golang-set 20170413, branch master, latest version v1.6 Package gxset implements a simple and generic set collection. Items stored within it are unordered and unique. It supports typical set operations: membership testing, intersection, union, difference, symmetric difference and cloning.

Package gxset provides two implementations. The default implementation is safe for concurrent access. There is a non-threadsafe implementation which is slightly more performant.

refs: https://github.com/deckarep/golang-set 20170413, branch master, latest version v1.6

refs: https://github.com/deckarep/golang-set 20170413, branch master, latest version v1.6

Index

• type Iterator
  • func (i *Iterator) Stop()
• type OrderedPair
  • func (pair *OrderedPair) Equal(other OrderedPair) bool
  • func (pair OrderedPair) String() string
• type Set
  • func NewSet(s ...interface{}) Set
  • func NewSetFromMapKey(m map[interface{}]interface{}) Set
  • func NewSetFromMapValue(m map[interface{}]interface{}) Set
  • func NewSetFromSlice(s []interface{}) Set
  • func NewSetWith(elts ...interface{}) Set
  • func NewThreadUnsafeSet() Set
  • func NewThreadUnsafeSetFromSlice(s []interface{}) Set

Examples

• Iterator

Types

type Iterator

type Iterator struct {
	C <-chan interface{}
	// contains filtered or unexported fields
}

Iterator defines an iterator over a Set, its C channel can be used to range over the Set's elements.

Example

// refs: https://github.com/deckarep/golang-set 20170413, branch master, latest version v1.6
package main

import (
	"fmt"
)

import (
	"github.com/davecgh/go-spew/spew"
)

type YourType struct {
	Name string
}

func main() {
	set := NewSetFromSlice([]interface{}{
		&YourType{Name: "Alise"},
		&YourType{Name: "Bob"},
		&YourType{Name: "John"},
		&YourType{Name: "Nick"},
	})

	fmt.Println("set:", spew.Sdump(set))

	var found *YourType = nil
	it := set.Iterator()

	for elem := range it.C {
		if elem.(*YourType).Name == "John" {
			found = elem.(*YourType)
			it.Stop()
		}
	}

	fmt.Printf("Found %+v\n", found)

}

Output:

Found &{Name:John}

func (*Iterator) Stop

func (i *Iterator) Stop()

Stop stops the Iterator, no further elements will be received on C, C will be closed.

type OrderedPair

type OrderedPair struct {
	First  interface{}
	Second interface{}
}

func (*OrderedPair) Equal

func (pair *OrderedPair) Equal(other OrderedPair) bool

func (OrderedPair) String

func (pair OrderedPair) String() string

type Set

type Set interface {
	// Adds an element to the set. Returns whether
	// the item was added.
	Add(i interface{}) bool

	// Returns the number of elements in the set.
	Cardinality() int

	// Removes all elements from the set, leaving
	// the emtpy set.
	Clear()

	// Returns a clone of the set using the same
	// implementation, duplicating all keys.
	Clone() Set

	// Returns whether the given items
	// are all in the set.
	Contains(i ...interface{}) bool

	// Returns the difference between this set
	// and other. The returned set will contain
	// all elements of this set that are not also
	// elements of other.
	//
	// Note that the argument to Difference
	// must be of the same type as the receiver
	// of the method. Otherwise, Difference will
	// panic.
	Difference(other Set) Set

	// Determines if two sets are equal to each
	// other. If they have the same cardinality
	// and contain the same elements, they are
	// considered equal. The order in which
	// the elements were added is irrelevant.
	//
	// Note that the argument to Equal must be
	// of the same type as the receiver of the
	// method. Otherwise, Equal will panic.
	Equal(other Set) bool

	// Returns a new set containing only the elements
	// that exist only in both sets.
	//
	// Note that the argument to Intersect
	// must be of the same type as the receiver
	// of the method. Otherwise, Intersect will
	// panic.
	Intersect(other Set) Set

	// Determines if every element in this set is in
	// the other set.
	//
	// Note that the argument to IsSubset
	// must be of the same type as the receiver
	// of the method. Otherwise, IsSubset will
	// panic.
	IsSubset(other Set) bool

	// Determines if every element in the other set
	// is in this set.
	//
	// Note that the argument to IsSuperset
	// must be of the same type as the receiver
	// of the method. Otherwise, IsSuperset will
	// panic.
	IsSuperset(other Set) bool

	// Returns a channel of elements that you can
	// range over.
	Iter() <-chan interface{}

	// Returns an Iterator object that you can
	// use to range over the set.
	Iterator() *Iterator

	// Remove a single element from the set.
	Remove(i interface{})

	// Provides a convenient string representation
	// of the current state of the set.
	String() string

	// Returns a new set with all elements which are
	// in either this set or the other set but not in both.
	//
	// Note that the argument to SymmetricDifference
	// must be of the same type as the receiver
	// of the method. Otherwise, SymmetricDifference
	// will panic.
	SymmetricDifference(other Set) Set

	// same type as the receiver of the method.
	// Otherwise, IsSuperset will panic.
	Union(other Set) Set

	// Returns all subsets of a given set (Power Set).
	PowerSet() Set

	// Returns the Cartesian Product of two sets.
	CartesianProduct(other Set) Set

	// Returns the members of the set as a slice.
	ToSlice() []interface{}
}

func NewSet

func NewSet(s ...interface{}) Set

Creates and returns a reference to an empty set.

func NewSetFromMapKey

func NewSetFromMapKey(m map[interface{}]interface{}) Set

Creates and returns a reference to a set from keys of @m.

func NewSetFromMapValue

func NewSetFromMapValue(m map[interface{}]interface{}) Set

Creates and returns a reference to a set from values of @m.

func NewSetFromSlice

func NewSetFromSlice(s []interface{}) Set

Creates and returns a reference to a set from an existing slice

func NewSetWith

func NewSetWith(elts ...interface{}) Set

Creates and returns a new set with the given elements

func NewThreadUnsafeSet

func NewThreadUnsafeSet() Set

func NewThreadUnsafeSetFromSlice

func NewThreadUnsafeSetFromSlice(s []interface{}) Set