// Reset eliminates all persisted message data in the store.
488535
func (store *MemoryStore) Reset() {
	store.Lock()
	defer store.Unlock()
	chkcond(store.opened)
	store.messages = make(map[string]packets.ControlPacket)
	WARN.Println(STR, "memorystore wiped")
}
398466
func (l *Logger) Reset() {
	l.ErrorCounter.Reset()
	if l.errors != nil {
		l.errors.Reset()
	}
}
968066
func (tl *testLogger) Reset() {
	tl.mux.Lock()
	defer tl.mux.Unlock()
	tl.entries = nil
}
281327
func (w *Writer) Reset() {
	if w.structRef != nil {
		for k := range w.structRef {
			delete(w.structRef, k)
		}
	}
	if w.Simple {
		return
	}
	w.refCount = 0
	if w.ref != nil {
		for k := range w.ref {
			delete(w.ref, k)
		}
	}
	if w.typeRef != nil {
		w.typeRef = w.typeRef[:0]
	}
}
200334
func reset() {
	registeredVersions = map[unversioned.GroupVersion]struct{}{}
	enabledVersions = map[unversioned.GroupVersion]struct{}{}
	groupMetaMap = map[string]*apimachinery.GroupMeta{}

}
592920
func (r *configs) Reset() {
	r.mu.Lock()
	defer r.mu.Unlock()
	r.m = make(map[string]*api.Config)
}
470054
func (a512srv *Avx512Server) reset(uid uint64) {

	// Check if there is a message still waiting to be processed (and remove if so)
	for i, lane := range a512srv.lanes {
		if lane.uid == uid {
			if lane.block != nil {
				a512srv.lanes[i] = Avx512LaneInfo{} // clear message
				a512srv.totalIn--
			}
		}
	}

	// Delete entry from hash map
	delete(a512srv.digests, uid)
}
871362
func (m *Map) Reset() {
	for hash, entry := range m.lookup {
		m.removeMapKey(hash, entry.key)
	}
}
1071326
func (s *Storage) Reset() {
	redisClient.Set(storage.TotalCountKey, strconv.Itoa(0), 0)
	redisClient.Set(storage.IosSuccessKey, strconv.Itoa(0), 0)
	redisClient.Set(storage.IosErrorKey, strconv.Itoa(0), 0)
	redisClient.Set(storage.AndroidSuccessKey, strconv.Itoa(0), 0)
	redisClient.Set(storage.AndroidErrorKey, strconv.Itoa(0), 0)
}
868690
func (store *FileStore) Reset() {
	store.Lock()
	defer store.Unlock()
	WARN.Println(STR, "FileStore Reset")
	for _, key := range store.all() {
		store.del(key)
	}
}
351506
func Reset(listener func(*vecty.Event)) *vecty.EventListener {
	return &vecty.EventListener{Name: "reset", Listener: listener}
}
516255
func (c *ChtIndexerBackend) Reset(ctx context.Context, section uint64, lastSectionHead common.Hash) error {
	var root common.Hash
	if section > 0 {
		root = GetChtRoot(c.diskdb, section-1, lastSectionHead)
	}
	var err error
	c.trie, err = trie.New(root, c.triedb)

	if err != nil && c.odr != nil {
		err = c.fetchMissingNodes(ctx, section, root)
		if err == nil {
			c.trie, err = trie.New(root, c.triedb)
		}
	}

	c.section = section
	return err
}
1202495
func (s *DynamicBanScore) Reset() {
	s.mtx.Lock()
	s.persistent = 0
	s.transient = 0
	s.lastUnix = 0
	s.mtx.Unlock()
}
1307340
func (cs *ConnStats) Reset() {
	atomic.StoreUint64(&cs.RPCCalls, 0)
	atomic.StoreUint64(&cs.RPCTime, 0)
	atomic.StoreUint64(&cs.BytesWritten, 0)
	atomic.StoreUint64(&cs.BytesRead, 0)
	atomic.StoreUint64(&cs.WriteCalls, 0)
	atomic.StoreUint64(&cs.WriteErrors, 0)
	atomic.StoreUint64(&cs.ReadCalls, 0)
	atomic.StoreUint64(&cs.ReadErrors, 0)
	atomic.StoreUint64(&cs.DialCalls, 0)
	atomic.StoreUint64(&cs.DialErrors, 0)
	atomic.StoreUint64(&cs.AcceptCalls, 0)
	atomic.StoreUint64(&cs.AcceptErrors, 0)
}
320852
func (d *Dropout) Reset() {
	d.handle = nil
	d.states = nil
	d.stateSizeInBytes = 0
	d.seed = 0
}
1137587
func (c *CipherReader) Reset(r io.Reader, mask [4]byte) {
	c.r = r
	c.mask = mask
	c.pos = 0
}
1282846
func (d *state) Reset() {
	// Zero the permutation's state.
	for i := range d.a {
		d.a[i] = 0
	}
	d.state = spongeAbsorbing
	d.buf = d.storage[:0]
}