llmongodb/counter.go

// counter
package main

import (
	"sync"
	"time"
)

// Counter structure
type Counter struct {
	mu   sync.Mutex
	user int
	log  int
	rem  int
	err  int
	dup  int
	time time.Duration
	wg   []int
}

// NewCounter iniitialized Counter structure
func NewCounter() *Counter {
	return &Counter{
		user: 0,
		log:  0,
		err:  0,
		rem:  0,
		dup:  0,
		time: 0,
		wg:   make([]int, opts.Concurrent),
	}
}

// AddUser increment number of users managed
func (c *Counter) AddUser() {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.user++
}

// AddDuplicate increment number of duplicates log
func (c *Counter) AddDuplicate() {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.dup++
}

// AddLog increment number of log's rows managed
func (c *Counter) AddLog(add int) {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.log += add
}

//AddRem increment removed logs row
func (c *Counter) AddRem(add int) {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.rem += add
}

// AddWG ...
func (c *Counter) AddWG(id int) {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.wg[id]++
}

// AddErr ...
func (c *Counter) AddErr() {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.err++
}

// DelWG ...
func (c *Counter) DelWG(id int) {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.wg[id]--
}

// GetUser return total users
func (c *Counter) GetUser() (ret int) {
	c.mu.Lock()
	defer c.mu.Unlock()
	ret = c.user
	return
}

// GetDup return total duplicated logins
func (c *Counter) GetDup() (ret int) {
	c.mu.Lock()
	defer c.mu.Unlock()
	ret = c.dup
	return
}

// GetLog return total log's rows
func (c *Counter) GetLog() (ret int) {
	c.mu.Lock()
	defer c.mu.Unlock()
	ret = c.log
	return
}

// GetErr return total errors
func (c *Counter) GetErr() (ret int) {
	c.mu.Lock()
	defer c.mu.Unlock()
	ret = c.err
	return
}

// GetRem return total removed log's rows
func (c *Counter) GetRem() (ret int) {
	c.mu.Lock()
	defer c.mu.Unlock()
	ret = c.rem
	return
}

// GetWG ...
func (c *Counter) GetWG(id int) (ret int) {
	c.mu.Lock()
	defer c.mu.Unlock()
	ret = c.wg[id]
	return
}

// GetTime ...
func (c *Counter) GetTime() (ret float64) {
	c.mu.Lock()
	defer c.mu.Unlock()
	ret = c.time.Seconds()
	return
}

// SetTime ...
func (c *Counter) SetTime(t time.Duration) {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.time = t
}