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. The default implementation is safe for concurrent access. There is a non-threadsafe implementation which is slightly more performant.

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 = 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)

}

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

func (*OrderedPair) Equal Uses

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

func (OrderedPair) String Uses

func (pair OrderedPair) String() string

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 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 Uses

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

Creates and returns a reference to an empty set.

func NewSetFromSlice Uses

func NewSetFromSlice(s []interface{}) Set

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

func NewSetWith Uses

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

Creates and returns a new set with the given elements

func NewThreadUnsafeSet Uses

func NewThreadUnsafeSet() Set

func NewThreadUnsafeSetFromSlice Uses

func NewThreadUnsafeSetFromSlice(s []interface{}) Set

Package mapset imports 6 packages (graph) and is imported by 72 packages. Updated 2017-04-21. Refresh now. Tools for package owners.