// Add starts recording a new duration
769434
func (s *DurationRatioStat) Add(k interface{}) {
	s.m.Lock()
	defer s.m.Unlock()
	if !s.isStarted {
		return
	}
	s.startedAt[k] = time.Now()
}
241086
func (c *Counter) Add(delta float64) {
	c.obs(c.name, lv.LabelValues{}, delta)
}
683526
func (lru *lru_ttl) Add(k, v interface{}, size int64) {
	lru.Delete(k)
	now := time.Now()
	e := &element_ttl{key: k, val: v, size: size, expiredOn: now.Add(lru.duration)}
	el := lru.list.PushBack(e)
	lru.elements[k] = el
	lru.size += size
	for (lru.size > lru.maxSize || lru.lastExpired(now)) && lru.deleteLast() {
		// left empty intentionally
	}
}
606837
func (c *baseCatcher) Add(err error) {
	if err == nil {
		return
	}

	c.mutex.Lock()
	defer c.mutex.Unlock()

	c.errs = append(c.errs, err)
}
119102
func (b *Broadcaster) Add(listener Listener) {
	b.listenerLock.Lock()
	defer b.listenerLock.Unlock()
	b.listeners = append(b.listeners, listener)
}
1116328
func (self *Record) Add(args RecordAdd) (*RecordInfo, error) {
	var res map[string]interface{}
	createArgs := map[string]interface{}{
		"name":  args.Name,
		"type":  args.Type,
		"value": args.Value,
		"ttl":   args.Ttl,
	}

	params := []interface{}{self.Key, args.Zone, args.Version, createArgs}
	if err := self.Call("domain.zone.record.add", params, &res); err != nil {
		return nil, err
	}
	return ToRecordInfo(res), nil
}
604334
func (s *ProcessingStats) Add(counter *uint64, amount int) {
	atomic.AddUint64(counter, uint64(amount))
}
556060
func (c *ExpirationCache) Add(obj interface{}) error {
	key, err := c.keyFunc(obj)
	if err != nil {
		return KeyError{obj, err}
	}
	c.cacheStorage.Add(key, &timestampedEntry{obj, c.clock.Now()})
	return nil
}
589333
func (v *Duration) Add(delta time.Duration) {
	v.i.Add(delta)
}
172620
func (c *Client) Add(data interface{}) error {
	c.ensureTransmission()
	c.ensureBuilder()
	return c.builder.Add(data)
}
304317
func (c *Counter) Add(i int) {
	c.Lock()
	c.count += i
	c.Unlock()
}
728191
func (f *RaceFreeFakeWatcher) Add(obj runtime.Object) {
	f.Lock()
	defer f.Unlock()
	if !f.Stopped {
		select {
		case f.result <- Event{Added, obj}:
			return
		default:
			panic(fmt.Errorf("channel full"))
		}
	}
}
680879
func (cd *CounterDuration) Add(delta time.Duration) {
	cd.i.Add(delta)
}
992863
func (d Duration) Add(v Duration) (Duration, error) {
	if &v == nil {
		return d, nil
	}
	dsum, err := AddInt64(int64(d.Duration), int64(v.Duration))
	if err != nil {
		return Duration{}, errors.Trace(err)
	}
	if d.Fsp >= v.Fsp {
		return Duration{Duration: gotime.Duration(dsum), Fsp: d.Fsp}, nil
	}
	return Duration{Duration: gotime.Duration(dsum), Fsp: v.Fsp}, nil
}
443656
func (c *ExpireCache) Add(key interface{}, value interface{}) {
	c.mutex.Lock()
	defer c.mutex.Unlock()

	record := expireRecord{
		Value:    value,
		ExpireAt: time.Now().UTC().Add(c.ttl),
	}
	// Add the record to the cache
	c.cache[key] = &record
}
586498
func (f *ListenerStack) Add(fx ElemEventMux) int {
	var ind int

	f.lock.RLock()
	ind = len(f.listeners)
	f.lock.RUnlock()

	f.lock.Lock()
	f.listeners = append(f.listeners, fx)
	f.lock.Unlock()

	return ind
}
1105690
func (t *Timer) Add(key string, value interface{}) {
	t.context.Add(key, value)
}