gring

Documentation

Overview

Package gring provides a concurrent-safe/unsafe ring(circular lists).

Index

• type Ring
  • func New(cap int, safe ...bool) *Ring
  • func (r *Ring) Cap() int
  • func (r *Ring) Len() int
  • func (r *Ring) Link(s *Ring) *Ring
  • func (r *Ring) Move(n int) *Ring
  • func (r *Ring) Next() *Ring
  • func (r *Ring) Prev() *Ring
  • func (r *Ring) Put(value interface{}) *Ring
  • func (r *Ring) RLockIteratorNext(f func(value interface{}) bool)
  • func (r *Ring) RLockIteratorPrev(f func(value interface{}) bool)
  • func (r *Ring) Set(value interface{}) *Ring
  • func (r *Ring) SliceNext() []interface{}
  • func (r *Ring) SlicePrev() []interface{}
  • func (r *Ring) Unlink(n int) *Ring
  • func (r *Ring) Val() interface{}

Examples

• New
• Ring.Cap
• Ring.Len
• Ring.Move
• Ring.Next
• Ring.Prev
• Ring.Put
• Ring.RLockIteratorNext
• Ring.RLockIteratorPrev
• Ring.Set
• Ring.SliceNext
• Ring.SlicePrev
• Ring.Unlink
• Ring.Val

Types

type Ring

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

Ring is a struct of ring structure.

func New

func New(cap int, safe ...bool) *Ring

New creates and returns a Ring structure of `cap` elements. The optional parameter `safe` specifies whether using this structure in concurrent safety, which is false in default.

Example

package main

import (
	"github.com/gogf/gf/v2/container/gring"
)

func main() {
	// Non concurrent safety
	gring.New(10)

	// Concurrent safety
	gring.New(10, true)

}

func (*Ring) Cap

func (r *Ring) Cap() int

Cap returns the capacity of ring.

Example

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gring"
)

func main() {
	r1 := gring.New(10)
	for i := 0; i < 5; i++ {
		r1.Set(i).Next()
	}
	fmt.Println("Cap:", r1.Cap())

	r2 := gring.New(10, true)
	for i := 0; i < 10; i++ {
		r2.Set(i).Next()
	}
	fmt.Println("Cap:", r2.Cap())

}

Output:

Cap: 10
Cap: 10

func (*Ring) Len

func (r *Ring) Len() int

Len returns the size of ring.

Example

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gring"
)

func main() {
	r1 := gring.New(10)
	for i := 0; i < 5; i++ {
		r1.Set(i).Next()
	}
	fmt.Println("Len:", r1.Len())

	r2 := gring.New(10, true)
	for i := 0; i < 10; i++ {
		r2.Set(i).Next()
	}
	fmt.Println("Len:", r2.Len())

}

Output:

Len: 5
Len: 10

func (*Ring) Link

func (r *Ring) Link(s *Ring) *Ring

Link connects ring r with ring s such that r.Next() becomes s and returns the original value for r.Next(). r must not be empty.

If r and s point to the same ring, linking them removes the elements between r and s from the ring. The removed elements form a sub-ring and the result is a reference to that sub-ring (if no elements were removed, the result is still the original value for r.Next(), and not nil).

If r and s point to different rings, linking them creates a single ring with the elements of s inserted after r. The result points to the element following the last element of s after insertion.

func (*Ring) Move

func (r *Ring) Move(n int) *Ring

Move moves n % r.Len() elements backward (n < 0) or forward (n >= 0) in the ring and returns that ring element. r must not be empty.

Example

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gring"
)

func main() {
	r := gring.New(10)
	for i := 0; i < 10; i++ {
		r.Set(i).Next()
	}
	// ring at Pos 0
	fmt.Println("CurVal:", r.Val())

	r.Move(5)

	// ring at Pos 5
	fmt.Println("CurVal:", r.Val())

}

Output:

CurVal: 0
CurVal: 5

func (*Ring) Next

func (r *Ring) Next() *Ring

Next returns the next ring element. r must not be empty.

Example

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gring"
)

func main() {
	r := gring.New(10)
	for i := 5; i > 0; i-- {
		r.Set(i).Prev()
	}

	fmt.Println("Prev:", r.Next().Val())
	fmt.Println("Prev:", r.Next().Val())

}

Output:

Prev: 1
Prev: 2

func (*Ring) Prev

func (r *Ring) Prev() *Ring

Prev returns the previous ring element. r must not be empty.

Example

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gring"
)

func main() {
	r := gring.New(10)
	for i := 0; i < 5; i++ {
		r.Set(i).Next()
	}

	fmt.Println("Prev:", r.Prev().Val())
	fmt.Println("Prev:", r.Prev().Val())

}

Output:

Prev: 4
Prev: 3

func (*Ring) Put

func (r *Ring) Put(value interface{}) *Ring

Put sets `value` to current item of ring and moves position to next item.

Example

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gring"
)

func main() {
	r := gring.New(10)
	r.Put(1)
	fmt.Println("Val:", r.Val())
	fmt.Println("Val:", r.Prev().Val())

}

Output:

Val: <nil>
Val: 1

func (*Ring) RLockIteratorNext

func (r *Ring) RLockIteratorNext(f func(value interface{}) bool)

RLockIteratorNext iterates and locks reading forward with given callback function `f` within RWMutex.RLock. If `f` returns true, then it continues iterating; or false to stop.

Example

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gring"
)

func main() {
	r := gring.New(10)
	for i := 0; i < 10; i++ {
		r.Set(i).Next()
	}

	r.RLockIteratorNext(func(value interface{}) bool {
		if value.(int) < 5 {
			fmt.Println("IteratorNext Success, Value:", value)
			return true
		}

		return false
	})

}

Output:

IteratorNext Success, Value: 0
IteratorNext Success, Value: 1
IteratorNext Success, Value: 2
IteratorNext Success, Value: 3
IteratorNext Success, Value: 4

func (*Ring) RLockIteratorPrev

func (r *Ring) RLockIteratorPrev(f func(value interface{}) bool)

RLockIteratorPrev iterates and locks writing backward with given callback function `f` within RWMutex.RLock. If `f` returns true, then it continues iterating; or false to stop.

Example

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gring"
)

func main() {
	r := gring.New(10)
	for i := 0; i < 10; i++ {
		r.Set(i).Next()
	}

	// move r to pos 9
	r.Prev()

	r.RLockIteratorPrev(func(value interface{}) bool {
		if value.(int) >= 5 {
			fmt.Println("IteratorPrev Success, Value:", value)
			return true
		}

		return false
	})

}

Output:

IteratorPrev Success, Value: 9
IteratorPrev Success, Value: 8
IteratorPrev Success, Value: 7
IteratorPrev Success, Value: 6
IteratorPrev Success, Value: 5

func (*Ring) Set

func (r *Ring) Set(value interface{}) *Ring

Set sets value to the item of current position.

Example

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gring"
)

func main() {
	r := gring.New(10)
	r.Set(1)
	fmt.Println("Val:", r.Val())

	r.Next().Set("GoFrame")
	fmt.Println("Val:", r.Val())

}

Output:

Val: 1
Val: GoFrame

func (*Ring) SliceNext

func (r *Ring) SliceNext() []interface{}

SliceNext returns a copy of all item values as slice forward from current position.

Example

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gring"
)

func main() {
	r := gring.New(10)
	for i := 0; i < 10; i++ {
		r.Set(i).Next()
	}

	fmt.Println(r.SliceNext())

}

Output:

[0 1 2 3 4 5 6 7 8 9]

func (*Ring) SlicePrev

func (r *Ring) SlicePrev() []interface{}

SlicePrev returns a copy of all item values as slice backward from current position.

Example

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gring"
)

func main() {
	r := gring.New(10)
	for i := 0; i < 10; i++ {
		r.Set(i).Next()
	}

	fmt.Println(r.SlicePrev())

}

Output:

[0 9 8 7 6 5 4 3 2 1]

func (*Ring) Unlink

func (r *Ring) Unlink(n int) *Ring

Unlink removes n % r.Len() elements from the ring r, starting at r.Next(). If n % r.Len() == 0, r remains unchanged. The result is the removed sub-ring. r must not be empty.

Example

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gring"
)

func main() {
	r := gring.New(10)
	for i := 0; i < 10; i++ {
		r.Set(i).Next()
	}

	fmt.Println("Before Unlink, Len:", r.Len())
	fmt.Println("Before Unlink, Cap:", r.Cap())
	fmt.Println("Before Unlink, ", r.SlicePrev())
	fmt.Println("Before Unlink, ", r.SliceNext())

	r.Unlink(7)

	fmt.Println("After Unlink, Len:", r.Len())
	fmt.Println("After Unlink, Cap:", r.Cap())
	fmt.Println("After Unlink, ", r.SlicePrev())
	fmt.Println("After Unlink, ", r.SliceNext())

}

Output:

Before Unlink, Len: 10
Before Unlink, Cap: 10
Before Unlink,  [0 9 8 7 6 5 4 3 2 1]
Before Unlink,  [0 1 2 3 4 5 6 7 8 9]
After Unlink, Len: 3
After Unlink, Cap: 3
After Unlink,  [0 9 8]
After Unlink,  [0 8 9]

func (*Ring) Val

func (r *Ring) Val() interface{}

Val returns the item's value of current position.

Example

package main

import (
	"fmt"

	"github.com/gogf/gf/v2/container/gring"
)

func main() {
	r := gring.New(10)
	r.Set(1)
	fmt.Println("Val:", r.Val())

	r.Next().Set("GoFrame")
	fmt.Println("Val:", r.Val())

}

Output:

Val: 1
Val: GoFrame