// Reset cleans up the request queue
793
func (s *BulkService) Reset() {
	s.requests = make([]BulkableRequest, 0)
	s.sizeInBytes = 0
	s.sizeInBytesCursor = 0
}
572084
func (c *CountingBloomFilter) Reset() *CountingBloomFilter {
	c.buckets.Reset()
	c.count = 0
	return c
}
1146357
func (w *ResponseRecorder) Reset() {
	w.ClearHeaders()
	w.WriteHeader(defaultStatusCode)
	w.ResetBody()
}
514095
func Reset(sel interface{}, opts ...QueryOption) Action {
	return QueryAfter(sel, func(ctx context.Context, nodes ...*cdp.Node) error {
		if len(nodes) < 1 {
			return fmt.Errorf("selector `%s` did not return any nodes", sel)
		}

		var res bool
		err := EvaluateAsDevTools(fmt.Sprintf(resetJS, nodes[0].FullXPath()), &res).Do(ctx)
		if err != nil {
			return err
		}

		if !res {
			return fmt.Errorf("could not call reset on node %d", nodes[0].NodeID)
		}

		return nil
	}, opts...)
}
1291125
func (s *Service) Reset(id int64) *ResetCall {
	c := &ResetCall{s: s, urlParams_: make(gensupport.URLParams)}
	c.id = id
	return c
}
1292087
func (c *CuckooFilter) Reset() *CuckooFilter {
	buckets := make([]bucket, c.m)
	for i := uint(0); i < c.m; i++ {
		buckets[i] = make(bucket, c.b)
	}
	c.buckets = buckets
	c.count = 0
	return c
}
398443
func (s *scheduler) reset() {
	s.lock.Lock()
	defer s.lock.Unlock()

	for section, res := range s.responses {
		if res.cached == nil {
			delete(s.responses, section)
		}
	}
}
1092793
func (cs *ConnStats) Reset() {
	cs.lock.Lock()
	cs.RPCCalls = 0
	cs.RPCTime = 0
	cs.BytesWritten = 0
	cs.BytesRead = 0
	cs.WriteCalls = 0
	cs.WriteErrors = 0
	cs.ReadCalls = 0
	cs.ReadErrors = 0
	cs.DialCalls = 0
	cs.DialErrors = 0
	cs.AcceptCalls = 0
	cs.AcceptErrors = 0
	cs.lock.Unlock()
}
351033
func (o *Once) Reset() {
	o.m.Lock()
	defer o.m.Unlock()
	atomic.StoreUint32(&o.done, 0)
}
1313211
func (it *Not) Reset() {
	it.result = nil
	it.primaryIt.Reset()
	it.allIt.Reset()
}
246607
func (m *Request) reset() {
	if m.Args != nil {
		m.Args = m.Args[:0]
	}
	if m.Labels != nil {
		m.Labels = m.Labels[:0]
	}
}
679737
func (s *PacketStore) Reset() {
	s.mutex.Lock()
	defer s.mutex.Unlock()

	s.packets = make(map[packet.ID]packet.Generic)
}
856242
func (m *EventHandler) Reset() {
	m.Events = []eh.Event{}
	m.Context = context.Background()
	m.Time = time.Time{}
}
1125290
func (a *AccountState) Reset(mctx libkb.MetaContext) {
	a.Lock()
	defer a.Unlock()

	a.refreshReqs = nil
	a.done = true
}
1143428
func (c *Cache) Reset() {
	c.Lock()
	defer c.Unlock()
	c.m = make(map[string]*list.Element, c.config.MaxItems)
	c.l.Init()
	c.size = 0
}
667670
func (c *Canceller) Reset() {
	c.ctx, c.cancel = context.WithCancel(context.Background())
}
1214157
func (q *TransmitLimitedQueue) Reset() {
	q.mu.Lock()
	defer q.mu.Unlock()

	q.walkReadOnlyLocked(false, func(cur *limitedBroadcast) bool {
		cur.b.Finished()
		return true
	})

	q.tq = nil
	q.tm = nil
	q.idGen = 0
}