datastructure

type Container interface {
	// Empty returns true if this container is empty; false otherwise.
	//
	// The result of this function is equivalent to the test Size() == 0, but
	// certain data structures that do not have an O(1) Size() implementation
	// may optimize this function.
	Empty() bool

	// Size returns the number of values in this container.
	Size() int

	// Clear resets this container to its zero-value state.
	Clear()

	// Values returns the values from this container as a slice of interface{}.
	Values() []interface{}

	// ValuesInto inserts the values from this container into the given slice.
	// The type of the into parameter must be a pointer to a slice for which
	// each value must be assignable by the type of every value in this
	// container.
	//
	// If the requirements for the into parameter are not met, this function
	// will panic.
	ValuesInto(into interface{})
}

type HashMap map[interface{}]interface{}

type LinkedHashMap struct {
	// contains filtered or unexported fields
}

type Map interface {
	Container

	// Contains returns true if the given key exists in this map.
	Contains(key interface{}) bool

	// Put adds the given key and value to the map. If the value already exists
	// in the map, the old value is overwritten by the specified value.
	//
	// Returns true if this map already contained an entry for this key, and
	// false otherwise.
	Put(key, value interface{}) bool

	// Get retrieves the value associated with the given key from the map.
	//
	// Returns the value, or nil if the key does not exist in the map, and a
	// boolean indicating whether the key exists.
	Get(key interface{}) (interface{}, bool)

	// GetInto retrieves the value associated with the given key from the map
	// and stores it in the into parameter passed to this function.
	//
	// The into parameter must be a pointer to a type assignable by the stored
	// value. If the given key does not exist in the map, the into parameter is
	// not modified.
	//
	// If the into parameter is not compatible with the stored value, this
	// function will panic.
	//
	// Returns true if the key exists, and false otherwise.
	GetInto(key interface{}, into interface{}) bool

	// Remove eliminates the given key from the map, and returns true if the key
	// existed in the map.
	Remove(key interface{}) bool

	// Keys returns the keys from this map as a slice of interface{}.
	Keys() []interface{}

	// KeysInto inserts the keys from this map into the given slice. The type of
	// the into parameter must be a pointer to a slice for which each value must
	// be assignable by the type of every key in this map.
	//
	// If the requirements for the into parameter are not met, this function
	// will panic.
	KeysInto(into interface{})

	// ForEach iterates each key-value pair in the map and executes the given
	// callback function. If the callback function returns an error, this
	// function will return the same error and immediately stop iteration.
	//
	// To stop iteration without returning an error, return ErrStopIteration.
	ForEach(fn MapIterationFunc) error

	// ForEachInto iterates each key-value pair in the map and executes the
	// given callback function, which must be of a type similar to
	// MapIterationFunc, except that the key and value parameters may be any
	// type assignable by every key and value in the map, respectively.
	//
	// If the requirements for the fn parameter are not met, this function will
	// panic.
	ForEachInto(fn interface{}) error
}

type MapBackedSet struct {
	// contains filtered or unexported fields
}

type MapIterationFunc func(key, value interface{}) error

type PriorityQueue struct {
	// contains filtered or unexported fields
}

type Set interface {
	Container

	// Contains returns true if the set contains all of the elements specified,
	// and false otherwise.
	Contains(elements ...interface{}) bool

	// Adds inserts all of the elements specified to the set. If an element
	// already exists in the set, it will not be duplicated.
	Add(elements ...interface{})

	// AddAll inserts the values from the given container to this set. If an
	// element already exists in the set, it will not be duplicated. Equivalent
	// to a set union operation.
	AddAll(other Container)

	// Remove eliminates all of the elements specified from the set.
	Remove(elements ...interface{})

	// RemoveAll removes the elements from the given set from this set.
	// Equivalent to a set difference operation.
	RemoveAll(other Set)

	// ForEach each element in the set and executes the given callback function.
	// If the callback function returns an error, this function will return the
	// same error and immediately stop iteration.
	//
	// To stop iteration without returning an error, return ErrStopIteration.
	ForEach(fn SetIterationFunc) error

	// ForEachInto iterates each element in the set and executes the given
	// callback function, which must be of a type similar to SetIterationFunc,
	// except that the element parameter may be any type assignable by every
	// element in the set.
	//
	// If the requirements for the fn parameter are not met, this function will
	// panic.
	ForEachInto(fn interface{}) error

	// RetailAll removes any elements that are not shared between this set and
	// the given set. Equivalent to a set intersection operation.
	RetainAll(other Set)
}

type SetIterationFunc func(element interface{}) error

type SynchronizedMap struct {
	// contains filtered or unexported fields
}

type SynchronizedSet struct {
	// contains filtered or unexported fields
}