Documentation

Overview

    Package gtree provides concurrent-safe/unsafe tree containers.

    Some implements are from: https://github.com/emirpasic/gods

    Index

    Constants

    This section is empty.

    Variables

    This section is empty.

    Functions

    This section is empty.

    Types

    type AVLTree

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

      AVLTree holds elements of the AVL tree.

      func NewAVLTree

      func NewAVLTree(comparator func(v1, v2 interface{}) int, safe ...bool) *AVLTree

        NewAVLTree instantiates an AVL tree with the custom key comparator. The parameter <safe> is used to specify whether using tree in concurrent-safety, which is false in default.

        func NewAVLTreeFrom

        func NewAVLTreeFrom(comparator func(v1, v2 interface{}) int, data map[interface{}]interface{}, safe ...bool) *AVLTree

          NewAVLTreeFrom instantiates an AVL tree with the custom key comparator and data map. The parameter <safe> is used to specify whether using tree in concurrent-safety, which is false in default.

          func (*AVLTree) Ceiling

          func (tree *AVLTree) Ceiling(key interface{}) (ceiling *AVLTreeNode, found bool)

            Ceiling finds ceiling node of the input key, return the ceiling node or nil if no ceiling node is found. Second return parameter is true if ceiling was found, otherwise false.

            Ceiling node is defined as the smallest node that is larger than or equal to the given node. A ceiling node may not be found, either because the tree is empty, or because all nodes in the tree is smaller than the given node.

            Key should adhere to the comparator's type assertion, otherwise method panics.

            func (*AVLTree) Clear

            func (tree *AVLTree) Clear()

              Clear removes all nodes from the tree.

              func (*AVLTree) Clone

              func (tree *AVLTree) Clone() *AVLTree

                Clone returns a new tree with a copy of current tree.

                func (*AVLTree) Contains

                func (tree *AVLTree) Contains(key interface{}) bool

                  Contains checks whether <key> exists in the tree.

                  func (*AVLTree) Flip

                  func (tree *AVLTree) Flip(comparator ...func(v1, v2 interface{}) int)

                    Flip exchanges key-value of the tree to value-key. Note that you should guarantee the value is the same type as key, or else the comparator would panic.

                    If the type of value is different with key, you pass the new <comparator>.

                    func (*AVLTree) Floor

                    func (tree *AVLTree) Floor(key interface{}) (floor *AVLTreeNode, found bool)

                      Floor Finds floor node of the input key, return the floor node or nil if no floor node is found. Second return parameter is true if floor was found, otherwise false.

                      Floor node is defined as the largest node that is smaller than or equal to the given node. A floor node may not be found, either because the tree is empty, or because all nodes in the tree is larger than the given node.

                      Key should adhere to the comparator's type assertion, otherwise method panics.

                      func (*AVLTree) Get

                      func (tree *AVLTree) Get(key interface{}) (value interface{})

                        Get searches the node in the tree by <key> and returns its value or nil if key is not found in tree.

                        func (*AVLTree) GetOrSet

                        func (tree *AVLTree) GetOrSet(key interface{}, value interface{}) interface{}

                          GetOrSet returns the value by key, or sets value with given <value> if it does not exist and then returns this value.

                          func (*AVLTree) GetOrSetFunc

                          func (tree *AVLTree) GetOrSetFunc(key interface{}, f func() interface{}) interface{}

                            GetOrSetFunc returns the value by key, or sets value with returned value of callback function <f> if it does not exist and then returns this value.

                            func (*AVLTree) GetOrSetFuncLock

                            func (tree *AVLTree) GetOrSetFuncLock(key interface{}, f func() interface{}) interface{}

                              GetOrSetFuncLock returns the value by key, or sets value with returned value of callback function <f> if it does not exist and then returns this value.

                              GetOrSetFuncLock differs with GetOrSetFunc function is that it executes function <f> with mutex.Lock of the hash map.

                              func (*AVLTree) GetVar

                              func (tree *AVLTree) GetVar(key interface{}) *gvar.Var

                                GetVar returns a gvar.Var with the value by given <key>. The returned gvar.Var is un-concurrent safe.

                                func (*AVLTree) GetVarOrSet

                                func (tree *AVLTree) GetVarOrSet(key interface{}, value interface{}) *gvar.Var

                                  GetVarOrSet returns a gvar.Var with result from GetVarOrSet. The returned gvar.Var is un-concurrent safe.

                                  func (*AVLTree) GetVarOrSetFunc

                                  func (tree *AVLTree) GetVarOrSetFunc(key interface{}, f func() interface{}) *gvar.Var

                                    GetVarOrSetFunc returns a gvar.Var with result from GetOrSetFunc. The returned gvar.Var is un-concurrent safe.

                                    func (*AVLTree) GetVarOrSetFuncLock

                                    func (tree *AVLTree) GetVarOrSetFuncLock(key interface{}, f func() interface{}) *gvar.Var

                                      GetVarOrSetFuncLock returns a gvar.Var with result from GetOrSetFuncLock. The returned gvar.Var is un-concurrent safe.

                                      func (*AVLTree) IsEmpty

                                      func (tree *AVLTree) IsEmpty() bool

                                        IsEmpty returns true if tree does not contain any nodes.

                                        func (*AVLTree) Iterator

                                        func (tree *AVLTree) Iterator(f func(key, value interface{}) bool)

                                          Iterator is alias of IteratorAsc.

                                          func (*AVLTree) IteratorAsc

                                          func (tree *AVLTree) IteratorAsc(f func(key, value interface{}) bool)

                                            IteratorAsc iterates the tree readonly in ascending order with given callback function <f>. If <f> returns true, then it continues iterating; or false to stop.

                                            func (*AVLTree) IteratorAscFrom

                                            func (tree *AVLTree) IteratorAscFrom(key interface{}, match bool, f func(key, value interface{}) bool)

                                              IteratorAscFrom iterates the tree readonly in ascending order with given callback function <f>. The parameter <key> specifies the start entry for iterating. The <match> specifies whether starting iterating if the <key> is fully matched, or else using index searching iterating. If <f> returns true, then it continues iterating; or false to stop.

                                              func (*AVLTree) IteratorDesc

                                              func (tree *AVLTree) IteratorDesc(f func(key, value interface{}) bool)

                                                IteratorDesc iterates the tree readonly in descending order with given callback function <f>. If <f> returns true, then it continues iterating; or false to stop.

                                                func (*AVLTree) IteratorDescFrom

                                                func (tree *AVLTree) IteratorDescFrom(key interface{}, match bool, f func(key, value interface{}) bool)

                                                  IteratorDescFrom iterates the tree readonly in descending order with given callback function <f>. The parameter <key> specifies the start entry for iterating. The <match> specifies whether starting iterating if the <key> is fully matched, or else using index searching iterating. If <f> returns true, then it continues iterating; or false to stop.

                                                  func (*AVLTree) IteratorFrom

                                                  func (tree *AVLTree) IteratorFrom(key interface{}, match bool, f func(key, value interface{}) bool)

                                                    IteratorFrom is alias of IteratorAscFrom.

                                                    func (*AVLTree) Keys

                                                    func (tree *AVLTree) Keys() []interface{}

                                                      Keys returns all keys in asc order.

                                                      func (*AVLTree) Left

                                                      func (tree *AVLTree) Left() *AVLTreeNode

                                                        Left returns the minimum element of the AVL tree or nil if the tree is empty.

                                                        func (*AVLTree) Map

                                                        func (tree *AVLTree) Map() map[interface{}]interface{}

                                                          Map returns all key-value items as map.

                                                          func (*AVLTree) MapStrAny

                                                          func (tree *AVLTree) MapStrAny() map[string]interface{}

                                                            MapStrAny returns all key-value items as map[string]interface{}.

                                                            func (*AVLTree) MarshalJSON

                                                            func (tree *AVLTree) MarshalJSON() ([]byte, error)

                                                              MarshalJSON implements the interface MarshalJSON for json.Marshal.

                                                              func (*AVLTree) Print

                                                              func (tree *AVLTree) Print()

                                                                Print prints the tree to stdout.

                                                                func (*AVLTree) Remove

                                                                func (tree *AVLTree) Remove(key interface{}) (value interface{})

                                                                  Remove removes the node from the tree by key. Key should adhere to the comparator's type assertion, otherwise method panics.

                                                                  func (*AVLTree) Removes

                                                                  func (tree *AVLTree) Removes(keys []interface{})

                                                                    Removes batch deletes values of the tree by <keys>.

                                                                    func (*AVLTree) Replace

                                                                    func (tree *AVLTree) Replace(data map[interface{}]interface{})

                                                                      Replace the data of the tree with given <data>.

                                                                      func (*AVLTree) Right

                                                                      func (tree *AVLTree) Right() *AVLTreeNode

                                                                        Right returns the maximum element of the AVL tree or nil if the tree is empty.

                                                                        func (*AVLTree) Search

                                                                        func (tree *AVLTree) Search(key interface{}) (value interface{}, found bool)

                                                                          Search searches the tree with given <key>. Second return parameter <found> is true if key was found, otherwise false.

                                                                          func (*AVLTree) Set

                                                                          func (tree *AVLTree) Set(key interface{}, value interface{})

                                                                            Set inserts node into the tree.

                                                                            func (*AVLTree) SetIfNotExist

                                                                            func (tree *AVLTree) SetIfNotExist(key interface{}, value interface{}) bool

                                                                              SetIfNotExist sets <value> to the map if the <key> does not exist, and then returns true. It returns false if <key> exists, and <value> would be ignored.

                                                                              func (*AVLTree) SetIfNotExistFunc

                                                                              func (tree *AVLTree) SetIfNotExistFunc(key interface{}, f func() interface{}) bool

                                                                                SetIfNotExistFunc sets value with return value of callback function <f>, and then returns true. It returns false if <key> exists, and <value> would be ignored.

                                                                                func (*AVLTree) SetIfNotExistFuncLock

                                                                                func (tree *AVLTree) SetIfNotExistFuncLock(key interface{}, f func() interface{}) bool

                                                                                  SetIfNotExistFuncLock sets value with return value of callback function <f>, and then returns true. It returns false if <key> exists, and <value> would be ignored.

                                                                                  SetIfNotExistFuncLock differs with SetIfNotExistFunc function is that it executes function <f> with mutex.Lock of the hash map.

                                                                                  func (*AVLTree) Sets

                                                                                  func (tree *AVLTree) Sets(data map[interface{}]interface{})

                                                                                    Sets batch sets key-values to the tree.

                                                                                    func (*AVLTree) Size

                                                                                    func (tree *AVLTree) Size() int

                                                                                      Size returns number of nodes in the tree.

                                                                                      func (*AVLTree) String

                                                                                      func (tree *AVLTree) String() string

                                                                                        String returns a string representation of container

                                                                                        func (*AVLTree) Values

                                                                                        func (tree *AVLTree) Values() []interface{}

                                                                                          Values returns all values in asc order based on the key.

                                                                                          type AVLTreeNode

                                                                                          type AVLTreeNode struct {
                                                                                          	Key   interface{}
                                                                                          	Value interface{}
                                                                                          	// contains filtered or unexported fields
                                                                                          }

                                                                                            AVLTreeNode is a single element within the tree.

                                                                                            func (*AVLTreeNode) Next

                                                                                            func (node *AVLTreeNode) Next() *AVLTreeNode

                                                                                              Next returns the next element in an inorder walk of the AVL tree.

                                                                                              func (*AVLTreeNode) Prev

                                                                                              func (node *AVLTreeNode) Prev() *AVLTreeNode

                                                                                                Prev returns the previous element in an inorder walk of the AVL tree.

                                                                                                type BTree

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

                                                                                                  BTree holds elements of the B-tree.

                                                                                                  func NewBTree

                                                                                                  func NewBTree(m int, comparator func(v1, v2 interface{}) int, safe ...bool) *BTree

                                                                                                    NewBTree instantiates a B-tree with <m> (maximum number of children) and a custom key comparator. The parameter <safe> is used to specify whether using tree in concurrent-safety, which is false in default. Note that the <m> must be greater or equal than 3, or else it panics.

                                                                                                    func NewBTreeFrom

                                                                                                    func NewBTreeFrom(m int, comparator func(v1, v2 interface{}) int, data map[interface{}]interface{}, safe ...bool) *BTree

                                                                                                      NewBTreeFrom instantiates a B-tree with <m> (maximum number of children), a custom key comparator and data map. The parameter <safe> is used to specify whether using tree in concurrent-safety, which is false in default.

                                                                                                      func (*BTree) Clear

                                                                                                      func (tree *BTree) Clear()

                                                                                                        Clear removes all nodes from the tree.

                                                                                                        func (*BTree) Clone

                                                                                                        func (tree *BTree) Clone() *BTree

                                                                                                          Clone returns a new tree with a copy of current tree.

                                                                                                          func (*BTree) Contains

                                                                                                          func (tree *BTree) Contains(key interface{}) bool

                                                                                                            Contains checks whether <key> exists in the tree.

                                                                                                            func (*BTree) Get

                                                                                                            func (tree *BTree) Get(key interface{}) (value interface{})

                                                                                                              Get searches the node in the tree by <key> and returns its value or nil if key is not found in tree.

                                                                                                              func (*BTree) GetOrSet

                                                                                                              func (tree *BTree) GetOrSet(key interface{}, value interface{}) interface{}

                                                                                                                GetOrSet returns the value by key, or sets value with given <value> if it does not exist and then returns this value.

                                                                                                                func (*BTree) GetOrSetFunc

                                                                                                                func (tree *BTree) GetOrSetFunc(key interface{}, f func() interface{}) interface{}

                                                                                                                  GetOrSetFunc returns the value by key, or sets value with returned value of callback function <f> if it does not exist and then returns this value.

                                                                                                                  func (*BTree) GetOrSetFuncLock

                                                                                                                  func (tree *BTree) GetOrSetFuncLock(key interface{}, f func() interface{}) interface{}

                                                                                                                    GetOrSetFuncLock returns the value by key, or sets value with returned value of callback function <f> if it does not exist and then returns this value.

                                                                                                                    GetOrSetFuncLock differs with GetOrSetFunc function is that it executes function <f> with mutex.Lock of the hash map.

                                                                                                                    func (*BTree) GetVar

                                                                                                                    func (tree *BTree) GetVar(key interface{}) *gvar.Var

                                                                                                                      GetVar returns a gvar.Var with the value by given <key>. The returned gvar.Var is un-concurrent safe.

                                                                                                                      func (*BTree) GetVarOrSet

                                                                                                                      func (tree *BTree) GetVarOrSet(key interface{}, value interface{}) *gvar.Var

                                                                                                                        GetVarOrSet returns a gvar.Var with result from GetVarOrSet. The returned gvar.Var is un-concurrent safe.

                                                                                                                        func (*BTree) GetVarOrSetFunc

                                                                                                                        func (tree *BTree) GetVarOrSetFunc(key interface{}, f func() interface{}) *gvar.Var

                                                                                                                          GetVarOrSetFunc returns a gvar.Var with result from GetOrSetFunc. The returned gvar.Var is un-concurrent safe.

                                                                                                                          func (*BTree) GetVarOrSetFuncLock

                                                                                                                          func (tree *BTree) GetVarOrSetFuncLock(key interface{}, f func() interface{}) *gvar.Var

                                                                                                                            GetVarOrSetFuncLock returns a gvar.Var with result from GetOrSetFuncLock. The returned gvar.Var is un-concurrent safe.

                                                                                                                            func (*BTree) Height

                                                                                                                            func (tree *BTree) Height() int

                                                                                                                              Height returns the height of the tree.

                                                                                                                              func (*BTree) IsEmpty

                                                                                                                              func (tree *BTree) IsEmpty() bool

                                                                                                                                Empty returns true if tree does not contain any nodes

                                                                                                                                func (*BTree) Iterator

                                                                                                                                func (tree *BTree) Iterator(f func(key, value interface{}) bool)

                                                                                                                                  Iterator is alias of IteratorAsc.

                                                                                                                                  func (*BTree) IteratorAsc

                                                                                                                                  func (tree *BTree) IteratorAsc(f func(key, value interface{}) bool)

                                                                                                                                    IteratorAsc iterates the tree readonly in ascending order with given callback function <f>. If <f> returns true, then it continues iterating; or false to stop.

                                                                                                                                    func (*BTree) IteratorAscFrom

                                                                                                                                    func (tree *BTree) IteratorAscFrom(key interface{}, match bool, f func(key, value interface{}) bool)

                                                                                                                                      IteratorAscFrom iterates the tree readonly in ascending order with given callback function <f>. The parameter <key> specifies the start entry for iterating. The <match> specifies whether starting iterating if the <key> is fully matched, or else using index searching iterating. If <f> returns true, then it continues iterating; or false to stop.

                                                                                                                                      func (*BTree) IteratorDesc

                                                                                                                                      func (tree *BTree) IteratorDesc(f func(key, value interface{}) bool)

                                                                                                                                        IteratorDesc iterates the tree readonly in descending order with given callback function <f>. If <f> returns true, then it continues iterating; or false to stop.

                                                                                                                                        func (*BTree) IteratorDescFrom

                                                                                                                                        func (tree *BTree) IteratorDescFrom(key interface{}, match bool, f func(key, value interface{}) bool)

                                                                                                                                          IteratorDescFrom iterates the tree readonly in descending order with given callback function <f>. The parameter <key> specifies the start entry for iterating. The <match> specifies whether starting iterating if the <key> is fully matched, or else using index searching iterating. If <f> returns true, then it continues iterating; or false to stop.

                                                                                                                                          func (*BTree) IteratorFrom

                                                                                                                                          func (tree *BTree) IteratorFrom(key interface{}, match bool, f func(key, value interface{}) bool)

                                                                                                                                            IteratorFrom is alias of IteratorAscFrom.

                                                                                                                                            func (*BTree) Keys

                                                                                                                                            func (tree *BTree) Keys() []interface{}

                                                                                                                                              Keys returns all keys in asc order.

                                                                                                                                              func (*BTree) Left

                                                                                                                                              func (tree *BTree) Left() *BTreeEntry

                                                                                                                                                Left returns the left-most (min) entry or nil if tree is empty.

                                                                                                                                                func (*BTree) Map

                                                                                                                                                func (tree *BTree) Map() map[interface{}]interface{}

                                                                                                                                                  Map returns all key-value items as map.

                                                                                                                                                  func (*BTree) MapStrAny

                                                                                                                                                  func (tree *BTree) MapStrAny() map[string]interface{}

                                                                                                                                                    MapStrAny returns all key-value items as map[string]interface{}.

                                                                                                                                                    func (*BTree) MarshalJSON

                                                                                                                                                    func (tree *BTree) MarshalJSON() ([]byte, error)

                                                                                                                                                      MarshalJSON implements the interface MarshalJSON for json.Marshal.

                                                                                                                                                      func (*BTree) Print

                                                                                                                                                      func (tree *BTree) Print()

                                                                                                                                                        Print prints the tree to stdout.

                                                                                                                                                        func (*BTree) Remove

                                                                                                                                                        func (tree *BTree) Remove(key interface{}) (value interface{})

                                                                                                                                                          Remove removes the node from the tree by <key>.

                                                                                                                                                          func (*BTree) Removes

                                                                                                                                                          func (tree *BTree) Removes(keys []interface{})

                                                                                                                                                            Removes batch deletes values of the tree by <keys>.

                                                                                                                                                            func (*BTree) Replace

                                                                                                                                                            func (tree *BTree) Replace(data map[interface{}]interface{})

                                                                                                                                                              Replace the data of the tree with given <data>.

                                                                                                                                                              func (*BTree) Right

                                                                                                                                                              func (tree *BTree) Right() *BTreeEntry

                                                                                                                                                                Right returns the right-most (max) entry or nil if tree is empty.

                                                                                                                                                                func (*BTree) Search

                                                                                                                                                                func (tree *BTree) Search(key interface{}) (value interface{}, found bool)

                                                                                                                                                                  Search searches the tree with given <key>. Second return parameter <found> is true if key was found, otherwise false.

                                                                                                                                                                  func (*BTree) Set

                                                                                                                                                                  func (tree *BTree) Set(key interface{}, value interface{})

                                                                                                                                                                    Set inserts key-value item into the tree.

                                                                                                                                                                    func (*BTree) SetIfNotExist

                                                                                                                                                                    func (tree *BTree) SetIfNotExist(key interface{}, value interface{}) bool

                                                                                                                                                                      SetIfNotExist sets <value> to the map if the <key> does not exist, and then returns true. It returns false if <key> exists, and <value> would be ignored.

                                                                                                                                                                      func (*BTree) SetIfNotExistFunc

                                                                                                                                                                      func (tree *BTree) SetIfNotExistFunc(key interface{}, f func() interface{}) bool

                                                                                                                                                                        SetIfNotExistFunc sets value with return value of callback function <f>, and then returns true. It returns false if <key> exists, and <value> would be ignored.

                                                                                                                                                                        func (*BTree) SetIfNotExistFuncLock

                                                                                                                                                                        func (tree *BTree) SetIfNotExistFuncLock(key interface{}, f func() interface{}) bool

                                                                                                                                                                          SetIfNotExistFuncLock sets value with return value of callback function <f>, and then returns true. It returns false if <key> exists, and <value> would be ignored.

                                                                                                                                                                          SetIfNotExistFuncLock differs with SetIfNotExistFunc function is that it executes function <f> with mutex.Lock of the hash map.

                                                                                                                                                                          func (*BTree) Sets

                                                                                                                                                                          func (tree *BTree) Sets(data map[interface{}]interface{})

                                                                                                                                                                            Sets batch sets key-values to the tree.

                                                                                                                                                                            func (*BTree) Size

                                                                                                                                                                            func (tree *BTree) Size() int

                                                                                                                                                                              Size returns number of nodes in the tree.

                                                                                                                                                                              func (*BTree) String

                                                                                                                                                                              func (tree *BTree) String() string

                                                                                                                                                                                String returns a string representation of container (for debugging purposes)

                                                                                                                                                                                func (*BTree) Values

                                                                                                                                                                                func (tree *BTree) Values() []interface{}

                                                                                                                                                                                  Values returns all values in asc order based on the key.

                                                                                                                                                                                  type BTreeEntry

                                                                                                                                                                                  type BTreeEntry struct {
                                                                                                                                                                                  	Key   interface{}
                                                                                                                                                                                  	Value interface{}
                                                                                                                                                                                  }

                                                                                                                                                                                    BTreeEntry represents the key-value pair contained within nodes.

                                                                                                                                                                                    type BTreeNode

                                                                                                                                                                                    type BTreeNode struct {
                                                                                                                                                                                    	Parent   *BTreeNode
                                                                                                                                                                                    	Entries  []*BTreeEntry // Contained keys in node
                                                                                                                                                                                    	Children []*BTreeNode  // Children nodes
                                                                                                                                                                                    }

                                                                                                                                                                                      BTreeNode is a single element within the tree.

                                                                                                                                                                                      type RedBlackTree

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

                                                                                                                                                                                        RedBlackTree holds elements of the red-black tree.

                                                                                                                                                                                        func NewRedBlackTree

                                                                                                                                                                                        func NewRedBlackTree(comparator func(v1, v2 interface{}) int, safe ...bool) *RedBlackTree

                                                                                                                                                                                          NewRedBlackTree instantiates a red-black tree with the custom key comparator. The parameter <safe> is used to specify whether using tree in concurrent-safety, which is false in default.

                                                                                                                                                                                          func NewRedBlackTreeFrom

                                                                                                                                                                                          func NewRedBlackTreeFrom(comparator func(v1, v2 interface{}) int, data map[interface{}]interface{}, safe ...bool) *RedBlackTree

                                                                                                                                                                                            NewRedBlackTreeFrom instantiates a red-black tree with the custom key comparator and <data> map. The parameter <safe> is used to specify whether using tree in concurrent-safety, which is false in default.

                                                                                                                                                                                            func (*RedBlackTree) Ceiling

                                                                                                                                                                                            func (tree *RedBlackTree) Ceiling(key interface{}) (ceiling *RedBlackTreeNode, found bool)

                                                                                                                                                                                              Ceiling finds ceiling node of the input key, return the ceiling node or nil if no ceiling node is found. Second return parameter is true if ceiling was found, otherwise false.

                                                                                                                                                                                              Ceiling node is defined as the smallest node that its key is larger than or equal to the given <key>. A ceiling node may not be found, either because the tree is empty, or because all nodes in the tree are smaller than the given node.

                                                                                                                                                                                              func (*RedBlackTree) Clear

                                                                                                                                                                                              func (tree *RedBlackTree) Clear()

                                                                                                                                                                                                Clear removes all nodes from the tree.

                                                                                                                                                                                                func (*RedBlackTree) Clone

                                                                                                                                                                                                func (tree *RedBlackTree) Clone() *RedBlackTree

                                                                                                                                                                                                  Clone returns a new tree with a copy of current tree.

                                                                                                                                                                                                  func (*RedBlackTree) Contains

                                                                                                                                                                                                  func (tree *RedBlackTree) Contains(key interface{}) bool

                                                                                                                                                                                                    Contains checks whether <key> exists in the tree.

                                                                                                                                                                                                    func (*RedBlackTree) Flip

                                                                                                                                                                                                    func (tree *RedBlackTree) Flip(comparator ...func(v1, v2 interface{}) int)

                                                                                                                                                                                                      Flip exchanges key-value of the tree to value-key. Note that you should guarantee the value is the same type as key, or else the comparator would panic.

                                                                                                                                                                                                      If the type of value is different with key, you pass the new <comparator>.

                                                                                                                                                                                                      func (*RedBlackTree) Floor

                                                                                                                                                                                                      func (tree *RedBlackTree) Floor(key interface{}) (floor *RedBlackTreeNode, found bool)

                                                                                                                                                                                                        Floor Finds floor node of the input key, return the floor node or nil if no floor node is found. Second return parameter is true if floor was found, otherwise false.

                                                                                                                                                                                                        Floor node is defined as the largest node that its key is smaller than or equal to the given <key>. A floor node may not be found, either because the tree is empty, or because all nodes in the tree are larger than the given node.

                                                                                                                                                                                                        func (*RedBlackTree) Get

                                                                                                                                                                                                        func (tree *RedBlackTree) Get(key interface{}) (value interface{})

                                                                                                                                                                                                          Get searches the node in the tree by <key> and returns its value or nil if key is not found in tree.

                                                                                                                                                                                                          func (*RedBlackTree) GetOrSet

                                                                                                                                                                                                          func (tree *RedBlackTree) GetOrSet(key interface{}, value interface{}) interface{}

                                                                                                                                                                                                            GetOrSet returns the value by key, or sets value with given <value> if it does not exist and then returns this value.

                                                                                                                                                                                                            func (*RedBlackTree) GetOrSetFunc

                                                                                                                                                                                                            func (tree *RedBlackTree) GetOrSetFunc(key interface{}, f func() interface{}) interface{}

                                                                                                                                                                                                              GetOrSetFunc returns the value by key, or sets value with returned value of callback function <f> if it does not exist and then returns this value.

                                                                                                                                                                                                              func (*RedBlackTree) GetOrSetFuncLock

                                                                                                                                                                                                              func (tree *RedBlackTree) GetOrSetFuncLock(key interface{}, f func() interface{}) interface{}

                                                                                                                                                                                                                GetOrSetFuncLock returns the value by key, or sets value with returned value of callback function <f> if it does not exist and then returns this value.

                                                                                                                                                                                                                GetOrSetFuncLock differs with GetOrSetFunc function is that it executes function <f> with mutex.Lock of the hash map.

                                                                                                                                                                                                                func (*RedBlackTree) GetVar

                                                                                                                                                                                                                func (tree *RedBlackTree) GetVar(key interface{}) *gvar.Var

                                                                                                                                                                                                                  GetVar returns a gvar.Var with the value by given <key>. The returned gvar.Var is un-concurrent safe.

                                                                                                                                                                                                                  func (*RedBlackTree) GetVarOrSet

                                                                                                                                                                                                                  func (tree *RedBlackTree) GetVarOrSet(key interface{}, value interface{}) *gvar.Var

                                                                                                                                                                                                                    GetVarOrSet returns a gvar.Var with result from GetVarOrSet. The returned gvar.Var is un-concurrent safe.

                                                                                                                                                                                                                    func (*RedBlackTree) GetVarOrSetFunc

                                                                                                                                                                                                                    func (tree *RedBlackTree) GetVarOrSetFunc(key interface{}, f func() interface{}) *gvar.Var

                                                                                                                                                                                                                      GetVarOrSetFunc returns a gvar.Var with result from GetOrSetFunc. The returned gvar.Var is un-concurrent safe.

                                                                                                                                                                                                                      func (*RedBlackTree) GetVarOrSetFuncLock

                                                                                                                                                                                                                      func (tree *RedBlackTree) GetVarOrSetFuncLock(key interface{}, f func() interface{}) *gvar.Var

                                                                                                                                                                                                                        GetVarOrSetFuncLock returns a gvar.Var with result from GetOrSetFuncLock. The returned gvar.Var is un-concurrent safe.

                                                                                                                                                                                                                        func (*RedBlackTree) IsEmpty

                                                                                                                                                                                                                        func (tree *RedBlackTree) IsEmpty() bool

                                                                                                                                                                                                                          IsEmpty returns true if tree does not contain any nodes.

                                                                                                                                                                                                                          func (*RedBlackTree) Iterator

                                                                                                                                                                                                                          func (tree *RedBlackTree) Iterator(f func(key, value interface{}) bool)

                                                                                                                                                                                                                            Iterator is alias of IteratorAsc.

                                                                                                                                                                                                                            func (*RedBlackTree) IteratorAsc

                                                                                                                                                                                                                            func (tree *RedBlackTree) IteratorAsc(f func(key, value interface{}) bool)

                                                                                                                                                                                                                              IteratorAsc iterates the tree readonly in ascending order with given callback function <f>. If <f> returns true, then it continues iterating; or false to stop.

                                                                                                                                                                                                                              func (*RedBlackTree) IteratorAscFrom

                                                                                                                                                                                                                              func (tree *RedBlackTree) IteratorAscFrom(key interface{}, match bool, f func(key, value interface{}) bool)

                                                                                                                                                                                                                                IteratorAscFrom iterates the tree readonly in ascending order with given callback function <f>. The parameter <key> specifies the start entry for iterating. The <match> specifies whether starting iterating if the <key> is fully matched, or else using index searching iterating. If <f> returns true, then it continues iterating; or false to stop.

                                                                                                                                                                                                                                func (*RedBlackTree) IteratorDesc

                                                                                                                                                                                                                                func (tree *RedBlackTree) IteratorDesc(f func(key, value interface{}) bool)

                                                                                                                                                                                                                                  IteratorDesc iterates the tree readonly in descending order with given callback function <f>. If <f> returns true, then it continues iterating; or false to stop.

                                                                                                                                                                                                                                  func (*RedBlackTree) IteratorDescFrom

                                                                                                                                                                                                                                  func (tree *RedBlackTree) IteratorDescFrom(key interface{}, match bool, f func(key, value interface{}) bool)

                                                                                                                                                                                                                                    IteratorDescFrom iterates the tree readonly in descending order with given callback function <f>. The parameter <key> specifies the start entry for iterating. The <match> specifies whether starting iterating if the <key> is fully matched, or else using index searching iterating. If <f> returns true, then it continues iterating; or false to stop.

                                                                                                                                                                                                                                    func (*RedBlackTree) IteratorFrom

                                                                                                                                                                                                                                    func (tree *RedBlackTree) IteratorFrom(key interface{}, match bool, f func(key, value interface{}) bool)

                                                                                                                                                                                                                                      IteratorFrom is alias of IteratorAscFrom.

                                                                                                                                                                                                                                      func (*RedBlackTree) Keys

                                                                                                                                                                                                                                      func (tree *RedBlackTree) Keys() []interface{}

                                                                                                                                                                                                                                        Keys returns all keys in asc order.

                                                                                                                                                                                                                                        func (*RedBlackTree) Left

                                                                                                                                                                                                                                        func (tree *RedBlackTree) Left() *RedBlackTreeNode

                                                                                                                                                                                                                                          Left returns the left-most (min) node or nil if tree is empty.

                                                                                                                                                                                                                                          func (*RedBlackTree) Map

                                                                                                                                                                                                                                          func (tree *RedBlackTree) Map() map[interface{}]interface{}

                                                                                                                                                                                                                                            Map returns all key-value items as map.

                                                                                                                                                                                                                                            func (*RedBlackTree) MapStrAny

                                                                                                                                                                                                                                            func (tree *RedBlackTree) MapStrAny() map[string]interface{}

                                                                                                                                                                                                                                              MapStrAny returns all key-value items as map[string]interface{}.

                                                                                                                                                                                                                                              func (*RedBlackTree) MarshalJSON

                                                                                                                                                                                                                                              func (tree *RedBlackTree) MarshalJSON() ([]byte, error)

                                                                                                                                                                                                                                                MarshalJSON implements the interface MarshalJSON for json.Marshal.

                                                                                                                                                                                                                                                func (*RedBlackTree) Print

                                                                                                                                                                                                                                                func (tree *RedBlackTree) Print()

                                                                                                                                                                                                                                                  Print prints the tree to stdout.

                                                                                                                                                                                                                                                  func (*RedBlackTree) Remove

                                                                                                                                                                                                                                                  func (tree *RedBlackTree) Remove(key interface{}) (value interface{})

                                                                                                                                                                                                                                                    Remove removes the node from the tree by <key>.

                                                                                                                                                                                                                                                    func (*RedBlackTree) Removes

                                                                                                                                                                                                                                                    func (tree *RedBlackTree) Removes(keys []interface{})

                                                                                                                                                                                                                                                      Removes batch deletes values of the tree by <keys>.

                                                                                                                                                                                                                                                      func (*RedBlackTree) Replace

                                                                                                                                                                                                                                                      func (tree *RedBlackTree) Replace(data map[interface{}]interface{})

                                                                                                                                                                                                                                                        Replace the data of the tree with given <data>.

                                                                                                                                                                                                                                                        func (*RedBlackTree) Right

                                                                                                                                                                                                                                                        func (tree *RedBlackTree) Right() *RedBlackTreeNode

                                                                                                                                                                                                                                                          Right returns the right-most (max) node or nil if tree is empty.

                                                                                                                                                                                                                                                          func (*RedBlackTree) Search

                                                                                                                                                                                                                                                          func (tree *RedBlackTree) Search(key interface{}) (value interface{}, found bool)

                                                                                                                                                                                                                                                            Search searches the tree with given <key>. Second return parameter <found> is true if key was found, otherwise false.

                                                                                                                                                                                                                                                            func (*RedBlackTree) Set

                                                                                                                                                                                                                                                            func (tree *RedBlackTree) Set(key interface{}, value interface{})

                                                                                                                                                                                                                                                              Set inserts key-value item into the tree.

                                                                                                                                                                                                                                                              func (*RedBlackTree) SetComparator

                                                                                                                                                                                                                                                              func (tree *RedBlackTree) SetComparator(comparator func(a, b interface{}) int)

                                                                                                                                                                                                                                                                SetComparator sets/changes the comparator for sorting.

                                                                                                                                                                                                                                                                func (*RedBlackTree) SetIfNotExist

                                                                                                                                                                                                                                                                func (tree *RedBlackTree) SetIfNotExist(key interface{}, value interface{}) bool

                                                                                                                                                                                                                                                                  SetIfNotExist sets <value> to the map if the <key> does not exist, and then returns true. It returns false if <key> exists, and <value> would be ignored.

                                                                                                                                                                                                                                                                  func (*RedBlackTree) SetIfNotExistFunc

                                                                                                                                                                                                                                                                  func (tree *RedBlackTree) SetIfNotExistFunc(key interface{}, f func() interface{}) bool

                                                                                                                                                                                                                                                                    SetIfNotExistFunc sets value with return value of callback function <f>, and then returns true. It returns false if <key> exists, and <value> would be ignored.

                                                                                                                                                                                                                                                                    func (*RedBlackTree) SetIfNotExistFuncLock

                                                                                                                                                                                                                                                                    func (tree *RedBlackTree) SetIfNotExistFuncLock(key interface{}, f func() interface{}) bool

                                                                                                                                                                                                                                                                      SetIfNotExistFuncLock sets value with return value of callback function <f>, and then returns true. It returns false if <key> exists, and <value> would be ignored.

                                                                                                                                                                                                                                                                      SetIfNotExistFuncLock differs with SetIfNotExistFunc function is that it executes function <f> with mutex.Lock of the hash map.

                                                                                                                                                                                                                                                                      func (*RedBlackTree) Sets

                                                                                                                                                                                                                                                                      func (tree *RedBlackTree) Sets(data map[interface{}]interface{})

                                                                                                                                                                                                                                                                        Sets batch sets key-values to the tree.

                                                                                                                                                                                                                                                                        func (*RedBlackTree) Size

                                                                                                                                                                                                                                                                        func (tree *RedBlackTree) Size() int

                                                                                                                                                                                                                                                                          Size returns number of nodes in the tree.

                                                                                                                                                                                                                                                                          func (*RedBlackTree) String

                                                                                                                                                                                                                                                                          func (tree *RedBlackTree) String() string

                                                                                                                                                                                                                                                                            String returns a string representation of container.

                                                                                                                                                                                                                                                                            func (*RedBlackTree) UnmarshalJSON

                                                                                                                                                                                                                                                                            func (tree *RedBlackTree) UnmarshalJSON(b []byte) error

                                                                                                                                                                                                                                                                              UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.

                                                                                                                                                                                                                                                                              func (*RedBlackTree) UnmarshalValue

                                                                                                                                                                                                                                                                              func (tree *RedBlackTree) UnmarshalValue(value interface{}) (err error)

                                                                                                                                                                                                                                                                                UnmarshalValue is an interface implement which sets any type of value for map.

                                                                                                                                                                                                                                                                                func (*RedBlackTree) Values

                                                                                                                                                                                                                                                                                func (tree *RedBlackTree) Values() []interface{}

                                                                                                                                                                                                                                                                                  Values returns all values in asc order based on the key.

                                                                                                                                                                                                                                                                                  type RedBlackTreeNode

                                                                                                                                                                                                                                                                                  type RedBlackTreeNode struct {
                                                                                                                                                                                                                                                                                  	Key   interface{}
                                                                                                                                                                                                                                                                                  	Value interface{}
                                                                                                                                                                                                                                                                                  	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                    RedBlackTreeNode is a single element within the tree.