README
¶
golang-set
Fork of deckarep's golang-set with generate code to make type-specific Sets, because I was sick of converting in and out of interfaces.
Comes with a bunch of sets based on basic types.
Doesn't support Cartesian Products or Power Sets yet.
Examples
To build
go build -o generate_set_exec ./generate_set
To generate a set for the time.Time object
./generate_set_exec -struct_name="time.Time" -import_path="time" -default_value="time.Time{}"
To generate a bunch of basic types
./generate_set_exec -make_defaults=`true`
Documentation
¶
Overview ¶
Package mapset 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 mapset provides two implementations of the Set interface. The default implementation is safe for concurrent access, but a non-thread-safe implementation is also provided for programs that can benefit from the slight speed improvement and that can enforce mutual exclusion through other means.
Index ¶
Examples ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
This section is empty.
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 ¶
package main
import (
"fmt"
)
type YourType struct {
Name string
}
func main() {
set := NewSetFromSlice([]interface{}{
&YourType{Name: "Alise"},
&YourType{Name: "Bob"},
&YourType{Name: "John"},
&YourType{Name: "Nick"},
})
var found *YourType
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}
type OrderedPair ¶
type OrderedPair struct {
First interface{}
Second interface{}
}
An OrderedPair represents a 2-tuple of values.
func (*OrderedPair) Equal ¶
func (pair *OrderedPair) Equal(other OrderedPair) bool
Equal says whether two 2-tuples contain the same values in the same order.
func (OrderedPair) String ¶
func (pair OrderedPair) String() string
String outputs a 2-tuple in the form "(A, B)".
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 empty 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 but the two sets are not equal.
//
// Note that the argument to IsProperSubset
// must be of the same type as the receiver
// of the method. Otherwise, IsProperSubset
// will panic.
IsProperSubset(other Set) bool
// Determines if every element in the other set
// is in this set but the two sets are not
// equal.
//
// Note that the argument to IsSuperset
// must be of the same type as the receiver
// of the method. Otherwise, IsSuperset will
// panic.
IsProperSuperset(other Set) bool
// 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
// Iterates over elements and executes the passed func against each element.
// If passed func returns true, stop iteration at the time.
Each(func(interface{}) 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
// Pop removes and returns an arbitrary item from the set.
Pop() interface{}
// 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{}
}
Set is the primary interface provided by the mapset package. It represents an unordered set of data and a large number of operations that can be applied to that set.
func NewSet ¶
func NewSet(s ...interface{}) Set
NewSet creates and returns a reference to an empty set. Operations on the resulting set are thread-safe.
func NewSetFromSlice ¶
func NewSetFromSlice(s []interface{}) Set
NewSetFromSlice creates and returns a reference to a set from an existing slice. Operations on the resulting set are thread-safe.
func NewSetWith ¶
func NewSetWith(elts ...interface{}) Set
NewSetWith creates and returns a new set with the given elements. Operations on the resulting set are thread-safe.
func NewThreadUnsafeSet ¶
func NewThreadUnsafeSet() Set
NewThreadUnsafeSet creates and returns a reference to an empty set. Operations on the resulting set are not thread-safe.
func NewThreadUnsafeSetFromSlice ¶
func NewThreadUnsafeSetFromSlice(s []interface{}) Set
NewThreadUnsafeSetFromSlice creates and returns a reference to a set from an existing slice. Operations on the resulting set are not thread-safe.
Source Files
Directories