version: 1.10

package ring

import "container/ring"

Overview

Package ring implements operations on circular lists.

Index

Examples

Package files

ring.go

type Ring

  1. type Ring struct {
  2.     Value interface{} // for use by client; untouched by this library
  3.     // contains filtered or unexported fields
  4. }

A Ring is an element of a circular list, or ring. Rings do not have a beginning
or end; a pointer to any ring element serves as reference to the entire ring.
Empty rings are represented as nil Ring pointers. The zero value for a Ring is a
one-element ring with a nil Value.

func New

  1. func New(n int) *Ring

New creates a ring of n elements.

func (*Ring) Do

  1. func (r *Ring) Do(f func(interface{}))

Do calls function f on each element of the ring, in forward order. The behavior
of Do is undefined if f changes *r.


Example:

  1. // Create a new ring of size 5
  2. r := ring.New(5)
  4. // Get the length of the ring
  5. n := r.Len()
  7. // Initialize the ring with some integer values
  8. for i := 0; i < n; i++ {
  9.     r.Value = i
  10.     r = r.Next()
  11. }
  13. // Iterate through the ring and print its contents
  14. r.Do(func(p interface{}) {
  15.     fmt.Println(p.(int))
  16. })
  18. // Output:
  19. // 0
  20. // 1
  21. // 2
  22. // 3
  23. // 4

func (*Ring) Len

  1. func (r *Ring) Len() int

Len computes the number of elements in ring r. It executes in time proportional
to the number of elements.


Example:

  1. // Create a new ring of size 4
  2. r := ring.New(4)
  4. // Print out its length
  5. fmt.Println(r.Len())
  7. // Output:
  8. // 4

  1. 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 subring and the result is a
reference to that subring (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.


Example:

  1. // Create two rings, r and s, of size 2
  2. r := ring.New(2)
  3. s := ring.New(2)
  5. // Get the length of the ring
  6. lr := r.Len()
  7. ls := s.Len()
  9. // Initialize r with 0s
  10. for i := 0; i < lr; i++ {
  11.     r.Value = 0
  12.     r = r.Next()
  13. }
  15. // Initialize s with 1s
  16. for j := 0; j < ls; j++ {
  17.     s.Value = 1
  18.     s = s.Next()
  19. }
  21. // Link ring r and ring s
  22. rs := r.Link(s)
  24. // Iterate through the combined ring and print its contents
  25. rs.Do(func(p interface{}) {
  26.     fmt.Println(p.(int))
  27. })
  29. // Output:
  30. // 0
  31. // 0
  32. // 1
  33. // 1

func (*Ring) Move

  1. 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:

  1. // Create a new ring of size 5
  2. r := ring.New(5)
  4. // Get the length of the ring
  5. n := r.Len()
  7. // Initialize the ring with some integer values
  8. for i := 0; i < n; i++ {
  9.     r.Value = i
  10.     r = r.Next()
  11. }
  13. // Move the pointer forward by three steps
  14. r = r.Move(3)
  16. // Iterate through the ring and print its contents
  17. r.Do(func(p interface{}) {
  18.     fmt.Println(p.(int))
  19. })
  21. // Output:
  22. // 3
  23. // 4
  24. // 0
  25. // 1
  26. // 2

func (*Ring) Next

  1. func (r *Ring) Next() *Ring

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


Example:

  1. // Create a new ring of size 5
  2. r := ring.New(5)
  4. // Get the length of the ring
  5. n := r.Len()
  7. // Initialize the ring with some integer values
  8. for i := 0; i < n; i++ {
  9.     r.Value = i
  10.     r = r.Next()
  11. }
  13. // Iterate through the ring and print its contents
  14. for j := 0; j < n; j++ {
  15.     fmt.Println(r.Value)
  16.     r = r.Next()
  17. }
  19. // Output:
  20. // 0
  21. // 1
  22. // 2
  23. // 3
  24. // 4

func (*Ring) Prev

  1. func (r *Ring) Prev() *Ring

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


Example:

  1. // Create a new ring of size 5
  2. r := ring.New(5)
  4. // Get the length of the ring
  5. n := r.Len()
  7. // Initialize the ring with some integer values
  8. for i := 0; i < n; i++ {
  9.     r.Value = i
  10.     r = r.Next()
  11. }
  13. // Iterate through the ring backwards and print its contents
  14. for j := 0; j < n; j++ {
  15.     r = r.Prev()
  16.     fmt.Println(r.Value)
  17. }
  19. // Output:
  20. // 4
  21. // 3
  22. // 2
  23. // 1
  24. // 0

  1. 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 subring. r must
not be empty.


Example:

  1. // Create a new ring of size 6
  2. r := ring.New(6)
  4. // Get the length of the ring
  5. n := r.Len()
  7. // Initialize the ring with some integer values
  8. for i := 0; i < n; i++ {
  9.     r.Value = i
  10.     r = r.Next()
  11. }
  13. // Unlink three elements from r, starting from r.Next()
  14. r.Unlink(3)
  16. // Iterate through the remaining ring and print its contents
  17. r.Do(func(p interface{}) {
  18.     fmt.Println(p.(int))
  19. })
  21. // Output:
  22. // 0
  23. // 4
  24. // 5