161 lines
2.5 KiB
Go
161 lines
2.5 KiB
Go
// counter
|
|
package m2r
|
|
|
|
import (
|
|
"sync"
|
|
"time"
|
|
)
|
|
|
|
// Counter structure
|
|
type Counter struct {
|
|
mu sync.Mutex
|
|
user int
|
|
log int
|
|
insert 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,
|
|
insert: 0,
|
|
err: 0,
|
|
rem: 0,
|
|
dup: 0,
|
|
time: 0,
|
|
wg: 0,
|
|
}
|
|
}
|
|
|
|
// 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(add int) {
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
c.dup += add
|
|
}
|
|
|
|
// AddInsert increment number of inserted rows
|
|
func (c *Counter) AddInsert(add int) {
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
c.insert += add
|
|
}
|
|
|
|
// 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() {
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
c.wg++
|
|
}
|
|
|
|
// AddErr ...
|
|
func (c *Counter) AddErr(add int) {
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
c.err += add
|
|
}
|
|
|
|
// DelWG ...
|
|
func (c *Counter) DelWG() {
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
c.wg--
|
|
}
|
|
|
|
// 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
|
|
}
|
|
|
|
// GetInsert return total inserted rows
|
|
func (c *Counter) GetInsert() (ret int) {
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
ret = c.insert
|
|
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() (ret int) {
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
ret = c.wg
|
|
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
|
|
}
|