// Add returns the timestamp as modified by the duration
962464
func (o Timestamp) Add(duration time.Duration) Timestamp {
	return o + Timestamp(duration/100)
}
1285480
func (twg *TimeoutWaitGroup) Add(delta int) {
	twg.mutex.Lock()
	defer twg.mutex.Unlock()
	if twg.workers == 0 {
		// waitgroups are reusable once workers is 0
		twg.last = nil
	} else if twg.workers > 0 && twg.last != nil {
		// This mimics normal WG behavior. Cannot add after Wait() has been
		// called, unless workers is 0.  Prevents races on Wait()
		panic("TimeoutWaitGroup misuse: Add called concurrently with Wait")
	}
	twg.workers += delta
}
311836
func (q *RateLimitedTimedQueue) Add(value string, uid interface{}) bool {
	now := now()
	return q.queue.Add(TimedValue{
		Value:     value,
		UID:       uid,
		AddedAt:   now,
		ProcessAt: now,
	})
}
983697
func (b *UpdateBuilder) Timestamp(t time.Time) *UpdateBuilder {
	b.using.Timestamp(t)
	return b
}
599260
func (r *ResetTimer) Add() {
	r.lock.Lock()
	defer r.lock.Unlock()
	state := int(atomic.LoadInt64(&r.state))
	// startd := int(atomic.LoadInt64(&r.started))

	if r.kill == nil {
		r.kill = make(chan struct{})
	}

	if r.reset == nil {
		r.reset = make(chan struct{})
	}

	if state > 0 {
		r.reset <- struct{}{}
	} else {
		r.runInit()
		r.handle()
		atomic.StoreInt64(&r.state, 1)
		atomic.StoreInt64(&r.started, 1)
	}
}
677941
func (c *modifiedTracker) add(st ManifestDiff_Stat) ManifestDiff_Stat {
	*c = *c || st != ManifestDiff_EQUAL
	return st
}
1093996
func (eng *Engine) Add(name string, value interface{}, tags ...Tag) {
	eng.measure(time.Now(), name, value, Counter, tags...)
}
89435
func (m *Mock) Add(d time.Duration) {
	// Calculate the final current time.
	t := m.now.Add(d)

	// Continue to execute timers until there are no more before the new time.
	for {
		if !m.runNextTimer(t) {
			break
		}
	}

	// Ensure that we end with the new time.
	m.mu.Lock()
	m.now = t
	m.mu.Unlock()

	// Give a small buffer to make sure the other goroutines get handled.
	gosched()
}
658787
func (vec *T) Add(v *T) *T {
	vec[0] += v[0]
	vec[1] += v[1]
	return vec
}
392837
func (mt *MultiTimings) Add(names []string, elapsed time.Duration) {
	if len(names) != len(mt.labels) {
		panic("MultiTimings: wrong number of values in Add")
	}
	mt.Timings.Add(safeJoinLabels(names), elapsed)
}
1230821
func (a Annotation) Add(key, value string) Annotation {
	a.setVal(key, value)
	return a
}
630480
func (p *Imports) Add(prev string, path string, bs []byte) error {
	p.Lock()
	defer p.Unlock()

	// TODO: align these with libsass name "stdin"
	if len(prev) == 0 || prev == "string" {
		prev = "stdin"
	}
	im := Import{
		bytes: bs,
		mod:   time.Now(),
		Prev:  prev,
		Path:  path,
	}

	p.m[prev+":"+path] = im
	return nil
}
460802
func (r *RollingBucket) Add(v float64) {
	r.AddAt(v, r.Timer.Now())
}
513047
func (t Term) Add(args ...interface{}) Term {
	return constructMethodTerm(t, "Add", p.Term_ADD, args, map[string]interface{}{})
}
315254
func (met *Metrics) Add(name string, value int64) {
	atomic.AddInt64(met.get(name), value)
}
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
}
900117
func (t *Time) Add(sc *stmtctx.StatementContext, d Duration) (Time, error) {
	sign, hh, mm, ss, micro := splitDuration(d.Duration)
	seconds, microseconds, _ := calcTimeDiff(t.Time, FromDate(0, 0, 0, hh, mm, ss, micro), -sign)
	days := seconds / secondsIn24Hour
	year, month, day := getDateFromDaynr(uint(days))
	var tm MysqlTime
	tm.year, tm.month, tm.day = uint16(year), uint8(month), uint8(day)
	calcTimeFromSec(&tm, seconds%secondsIn24Hour, microseconds)
	if t.Type == mysql.TypeDate {
		tm.hour = 0
		tm.minute = 0
		tm.second = 0
		tm.microsecond = 0
	}
	fsp := t.Fsp
	if d.Fsp > fsp {
		fsp = d.Fsp
	}
	ret := Time{
		Time: tm,
		Type: t.Type,
		Fsp:  fsp,
	}
	return ret, ret.Check(sc)
}