Documentation

Overview

    Package glist provides most commonly used doubly linked list container which also supports concurrent-safe/unsafe switch feature.

    Index

    Examples

    Constants

    This section is empty.

    Variables

    This section is empty.

    Functions

    This section is empty.

    Types

    type Element

    type Element = list.Element

      Element the item type of the list.

      type List

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

        List is a doubly linked list containing a concurrent-safe/unsafe switch. The switch should be set when its initialization and cannot be changed then.

        func New

        func New(safe ...bool) *List

          New creates and returns a new empty doubly linked list.

          Example
          Output:
          
          10
          [0 1 2 3 4 5 6 7 8 9]
          [9 8 7 6 5 4 3 2 1 0]
          0123456789
          0
          

          func NewFrom

          func NewFrom(array []interface{}, safe ...bool) *List

            NewFrom creates and returns a list from a copy of given slice <array>. The parameter <safe> is used to specify whether using list in concurrent-safety, which is false in default.

            func (*List) Back

            func (l *List) Back() (e *Element)

              Back returns the last element of list <l> or nil if the list is empty.

              func (*List) BackAll

              func (l *List) BackAll() (values []interface{})

                BackAll copies and returns values of all elements from back of <l> as slice.

                func (*List) BackValue

                func (l *List) BackValue() (value interface{})

                  BackValue returns value of the last element of <l> or nil if the list is empty.

                  func (*List) Clear

                  func (l *List) Clear()

                    See RemoveAll().

                    func (*List) Front

                    func (l *List) Front() (e *Element)

                      Front returns the first element of list <l> or nil if the list is empty.

                      func (*List) FrontAll

                      func (l *List) FrontAll() (values []interface{})

                        FrontAll copies and returns values of all elements from front of <l> as slice.

                        func (*List) FrontValue

                        func (l *List) FrontValue() (value interface{})

                          FrontValue returns value of the first element of <l> or nil if the list is empty.

                          func (*List) InsertAfter

                          func (l *List) InsertAfter(p *Element, v interface{}) (e *Element)

                            InsertAfter inserts a new element <e> with value <v> immediately after <p> and returns <e>. If <p> is not an element of <l>, the list is not modified. The <p> must not be nil.

                            func (*List) InsertBefore

                            func (l *List) InsertBefore(p *Element, v interface{}) (e *Element)

                              InsertBefore inserts a new element <e> with value <v> immediately before <p> and returns <e>. If <p> is not an element of <l>, the list is not modified. The <p> must not be nil.

                              func (*List) Iterator

                              func (l *List) Iterator(f func(e *Element) bool)

                                Iterator is alias of IteratorAsc.

                                func (*List) IteratorAsc

                                func (l *List) IteratorAsc(f func(e *Element) bool)

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

                                  Example
                                  Output:
                                  
                                  12345678910
                                  

                                  func (*List) IteratorDesc

                                  func (l *List) IteratorDesc(f func(e *Element) bool)

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

                                    Example
                                    Output:
                                    
                                    10987654321
                                    

                                    func (*List) Join

                                    func (l *List) Join(glue string) string

                                      Join joins list elements with a string <glue>.

                                      Example
                                      Output:
                                      
                                      a,b,c,d
                                      

                                      func (*List) Len

                                      func (l *List) Len() (length int)

                                        Len returns the number of elements of list <l>. The complexity is O(1).

                                        func (*List) LockFunc

                                        func (l *List) LockFunc(f func(list *list.List))

                                          LockFunc locks writing with given callback function <f> within RWMutex.Lock.

                                          Example
                                          Output:
                                          
                                          [1,2,3,4,5,M,7,8,9,10]
                                          

                                          func (*List) MarshalJSON

                                          func (l *List) MarshalJSON() ([]byte, error)

                                            MarshalJSON implements the interface MarshalJSON for json.Marshal.

                                            func (*List) MoveAfter

                                            func (l *List) MoveAfter(e, p *Element)

                                              MoveAfter moves element <e> to its new position after <p>. If <e> or <p> is not an element of <l>, or <e> == <p>, the list is not modified. The element and <p> must not be nil.

                                              func (*List) MoveBefore

                                              func (l *List) MoveBefore(e, p *Element)

                                                MoveBefore moves element <e> to its new position before <p>. If <e> or <p> is not an element of <l>, or <e> == <p>, the list is not modified. The element and <p> must not be nil.

                                                func (*List) MoveToBack

                                                func (l *List) MoveToBack(e *Element)

                                                  MoveToBack moves element <e> to the back of list <l>. If <e> is not an element of <l>, the list is not modified. The element must not be nil.

                                                  func (*List) MoveToFront

                                                  func (l *List) MoveToFront(e *Element)

                                                    MoveToFront moves element <e> to the front of list <l>. If <e> is not an element of <l>, the list is not modified. The element must not be nil.

                                                    func (*List) PopBack

                                                    func (l *List) PopBack() (value interface{})

                                                      PopBack removes the element from back of <l> and returns the value of the element.

                                                      Example
                                                      Output:
                                                      
                                                      9
                                                      

                                                      func (*List) PopBackAll

                                                      func (l *List) PopBackAll() []interface{}

                                                        PopBackAll removes all elements from back of <l> and returns values of the removed elements as slice.

                                                        func (*List) PopBacks

                                                        func (l *List) PopBacks(max int) (values []interface{})

                                                          PopBacks removes <max> elements from back of <l> and returns values of the removed elements as slice.

                                                          Example
                                                          Output:
                                                          
                                                          [9 8]
                                                          

                                                          func (*List) PopFront

                                                          func (l *List) PopFront() (value interface{})

                                                            PopFront removes the element from front of <l> and returns the value of the element.

                                                            Example
                                                            Output:
                                                            
                                                            1
                                                            

                                                            func (*List) PopFrontAll

                                                            func (l *List) PopFrontAll() []interface{}

                                                              PopFrontAll removes all elements from front of <l> and returns values of the removed elements as slice.

                                                              func (*List) PopFronts

                                                              func (l *List) PopFronts(max int) (values []interface{})

                                                                PopFronts removes <max> elements from front of <l> and returns values of the removed elements as slice.

                                                                Example
                                                                Output:
                                                                
                                                                [1 2]
                                                                

                                                                func (*List) PushBack

                                                                func (l *List) PushBack(v interface{}) (e *Element)

                                                                  PushBack inserts a new element <e> with value <v> at the back of list <l> and returns <e>.

                                                                  func (*List) PushBackList

                                                                  func (l *List) PushBackList(other *List)

                                                                    PushBackList inserts a copy of an other list at the back of list <l>. The lists <l> and <other> may be the same, but they must not be nil.

                                                                    func (*List) PushBacks

                                                                    func (l *List) PushBacks(values []interface{})

                                                                      PushBacks inserts multiple new elements with values <values> at the back of list <l>.

                                                                      func (*List) PushFront

                                                                      func (l *List) PushFront(v interface{}) (e *Element)

                                                                        PushFront inserts a new element <e> with value <v> at the front of list <l> and returns <e>.

                                                                        func (*List) PushFrontList

                                                                        func (l *List) PushFrontList(other *List)

                                                                          PushFrontList inserts a copy of an other list at the front of list <l>. The lists <l> and <other> may be the same, but they must not be nil.

                                                                          func (*List) PushFronts

                                                                          func (l *List) PushFronts(values []interface{})

                                                                            PushFronts inserts multiple new elements with values <values> at the front of list <l>.

                                                                            func (*List) RLockFunc

                                                                            func (l *List) RLockFunc(f func(list *list.List))

                                                                              RLockFunc locks reading with given callback function <f> within RWMutex.RLock.

                                                                              Example
                                                                              Output:
                                                                              
                                                                              12345678910
                                                                              10987654321
                                                                              

                                                                              func (*List) Remove

                                                                              func (l *List) Remove(e *Element) (value interface{})

                                                                                Remove removes <e> from <l> if <e> is an element of list <l>. It returns the element value e.Value. The element must not be nil.

                                                                                func (*List) RemoveAll

                                                                                func (l *List) RemoveAll()

                                                                                  RemoveAll removes all elements from list <l>.

                                                                                  func (*List) Removes

                                                                                  func (l *List) Removes(es []*Element)

                                                                                    Removes removes multiple elements <es> from <l> if <es> are elements of list <l>.

                                                                                    func (*List) Size

                                                                                    func (l *List) Size() int

                                                                                      Size is alias of Len.

                                                                                      func (*List) String

                                                                                      func (l *List) String() string

                                                                                        String returns current list as a string.

                                                                                        func (*List) UnmarshalJSON

                                                                                        func (l *List) UnmarshalJSON(b []byte) error

                                                                                          UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.

                                                                                          func (*List) UnmarshalValue

                                                                                          func (l *List) UnmarshalValue(value interface{}) (err error)

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

                                                                                            Source Files