golang-set: github.com/deckarep/golang-set Index | Examples | Files

package mapset

import "github.com/deckarep/golang-set"

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

Package Files

iterator.go set.go threadsafe.go threadunsafe.go

type Iterator Uses

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.

Code:

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)

}

func (*Iterator) Stop Uses

func (i *Iterator) Stop()

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

type OrderedPair Uses

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

An OrderedPair represents a 2-tuple of values.

func (*OrderedPair) Equal Uses

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

Equal says whether two 2-tuples contain the same values in the same order.

func (OrderedPair) String Uses

func (pair OrderedPair) String() string

String outputs a 2-tuple in the form "(A, B)".

type Set Uses

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

    // 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{}
}

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 Uses

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 Uses

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 Uses

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 Uses

func NewThreadUnsafeSet() Set

NewThreadUnsafeSet creates and returns a reference to an empty set. Operations on the resulting set are not thread-safe.

func NewThreadUnsafeSetFromSlice Uses

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.

Package mapset imports 6 packages (graph) and is imported by 101 packages. Updated 2017-08-30. Refresh now. Tools for package owners.