counter

Documentation

Index

• type Counter
  • func NewCounter[K comparable, V generic.Number]() *Counter[K, V]
  • func (slf *Counter[K, V]) Add(key K, value V, expired ...time.Duration)
  • func (slf *Counter[K, V]) AddWithMark(mark, key K, value V, expired time.Duration)
  • func (slf *Counter[K, V]) Get(key K) V
  • func (slf *Counter[K, V]) GetCounts() map[K]V
  • func (slf *Counter[K, V]) GetSubCounters() map[K]*Counter[K, V]
  • func (slf *Counter[K, V]) Reset(key K)
  • func (slf *Counter[K, V]) ResetAll()
  • func (slf *Counter[K, V]) ResetExpired(key K)
  • func (slf *Counter[K, V]) ResetExpiredMark(mark, key K)
  • func (slf *Counter[K, V]) ResetMark(mark, key K)
  • func (slf *Counter[K, V]) Shadow() *Shadow[K, V]
  • func (slf *Counter[K, V]) SubCounter(key K) *Counter[K, V]
• type Shadow
  • func (slf *Shadow[K, V]) ToCounter() *Counter[K, V]
• type SimpleDeduplication
  • func NewSimpleDeduplication[K comparable, V generic.Number]() *SimpleDeduplication[K, V]
  • func (slf *SimpleDeduplication[K, V]) Add(key K, value V)
  • func (slf *SimpleDeduplication[K, V]) Get() V

Types

type Counter

type Counter[K comparable, V generic.Number] struct {
	// contains filtered or unexported fields
}

Counter 计数器

func NewCounter

func NewCounter[K comparable, V generic.Number]() *Counter[K, V]

NewCounter 创建一个计数器

func (*Counter[K, V]) Add

func (slf *Counter[K, V]) Add(key K, value V, expired ...time.Duration)

Add 添加计数

• 当设置了 expired 时，在 expired 时间内，不会重复计数
• 需要注意的是，当第一次设置了 expired，第二次未设置时，第二次的计数将生效

func (*Counter[K, V]) AddWithMark

func (slf *Counter[K, V]) AddWithMark(mark, key K, value V, expired time.Duration)

AddWithMark 添加计数，根据 mark 判断是否重复计数

func (*Counter[K, V]) Get

func (slf *Counter[K, V]) Get(key K) V

Get 获取计数

func (*Counter[K, V]) GetCounts

func (slf *Counter[K, V]) GetCounts() map[K]V

GetCounts 获取计数器的所有计数

func (*Counter[K, V]) GetSubCounters

func (slf *Counter[K, V]) GetSubCounters() map[K]*Counter[K, V]

GetSubCounters 获取计数器的所有子计数器

func (*Counter[K, V]) Reset

func (slf *Counter[K, V]) Reset(key K)

Reset 重置特定 key 的计数

• 当 key 为一个子计数器时，将会重置该子计数器

func (*Counter[K, V]) ResetAll

func (slf *Counter[K, V]) ResetAll()

ResetAll 重置所有计数

func (*Counter[K, V]) ResetExpired

func (slf *Counter[K, V]) ResetExpired(key K)

ResetExpired 重置特定 key 的过期时间

func (*Counter[K, V]) ResetExpiredMark

func (slf *Counter[K, V]) ResetExpiredMark(mark, key K)

ResetExpiredMark 重置特定 mark 的 key 的过期时间

func (*Counter[K, V]) ResetMark

func (slf *Counter[K, V]) ResetMark(mark, key K)

ResetMark 重置特定 mark 的 key 的计数

func (*Counter[K, V]) Shadow

func (slf *Counter[K, V]) Shadow() *Shadow[K, V]

Shadow 获取该计数器的影子计数器，影子计数器的任何操作都不会影响到原计数器

• 适用于持久化等场景

func (*Counter[K, V]) SubCounter

func (slf *Counter[K, V]) SubCounter(key K) *Counter[K, V]

SubCounter 获取子计数器

type Shadow

type Shadow[K comparable, V generic.Number] struct {
	Sub                     bool                // 是否为子计数器
	DeduplicationRecord     map[K]int64         // 最后一次写入时间
	DeduplicationRecordMark map[string]int64    // 最后一次写入时间
	Counter                 map[K]V             // 计数器
	SubCounters             map[K]*Shadow[K, V] // 子计数器
}

Shadow 计数器的影子计数器

func (*Shadow[K, V]) ToCounter

func (slf *Shadow[K, V]) ToCounter() *Counter[K, V]

ToCounter 将影子计数器转换为计数器

type SimpleDeduplication

type SimpleDeduplication[K comparable, V generic.Number] struct {
	// contains filtered or unexported fields
}

SimpleDeduplication 简单去重计数器

func NewSimpleDeduplication

func NewSimpleDeduplication[K comparable, V generic.Number]() *SimpleDeduplication[K, V]

NewSimpleDeduplication 创建一个简单去重计数器

• 该计数器不会记录每个 key 的计数，只会记录 key 的存在与否
• 当 key 不存在时，计数器会将 key 记录为存在，并将计数器增加特定的值

func (*SimpleDeduplication[K, V]) Add

func (slf *SimpleDeduplication[K, V]) Add(key K, value V)

Add 添加计数，根据 key 判断是否重复计数

func (*SimpleDeduplication[K, V]) Get

func (slf *SimpleDeduplication[K, V]) Get() V

Get 获取计数