/* Clear all state */
185751
func (hash *TermsHashImpl) reset() {
	// we don't reuse so we drop everything and don't fill with 0
	hash.intPool.Reset(false, false)
	hash.bytePool.Reset(false, false)
}
686907
func (s *CfgEndpointState) Clear() error {
	key := fmt.Sprintf(endpointConfigPath, s.ID)
	return s.StateDriver.ClearState(key)
}
1346357
func (m *SecureMap) Clear() {
	m.lock.Lock()
	m.data = make(map[interface{}]interface{})
	m.lock.Unlock()
}
1236716
func (c *modelStateCollection) RemoveAll(query interface{}) (*mgo.ChangeInfo, error) {
	return c.WriteCollection.RemoveAll(c.mungeQuery(query))
}
625234
func (l *Loader) ClearAll() Interface {
	l.cacheLock.Lock()
	l.cache.Clear()
	l.cacheLock.Unlock()
	return l
}
1069549
func (s *CfgPolicyRule) Clear() error {
	key := fmt.Sprintf(policyRuleConfigPath, s.RuleId)
	return s.StateDriver.ClearState(key)
}
256767
func (c *Conn) Clear() {
	c.statsMut.Lock()
	defer c.statsMut.Unlock()

	c.commands = []*Cmd{}
	c.queue = []queueElement{}
	c.replies = []replyElement{}
	c.stats = make(map[cmdHash]int)
}
497750
func (h *Handle) Clear() {
	h.mu.Lock()
	h.StatsCache.Store(StatsCache{})
	h.mu.lastVersion = 0
	for len(h.ddlEventCh) > 0 {
		<-h.ddlEventCh
	}
	h.feedback = h.feedback[:0]
	h.mu.ctx.GetSessionVars().InitChunkSize = 1
	h.mu.ctx.GetSessionVars().MaxChunkSize = 32
	h.listHead = &SessionStatsCollector{mapper: make(tableDeltaMap), rateMap: make(errorRateDeltaMap)}
	h.globalMap = make(tableDeltaMap)
	h.mu.rateMap = make(errorRateDeltaMap)
	h.mu.Unlock()
}
143132
func (me *Event) Clear() {
	if me.closed {
		me.ch = nil
		me.closed = false
	}
}
1077117
func (af *aggFunction) Clear() {
	af.resultMapper = make(aggCtxMapper, 0)
	af.streamCtx = nil
}
574037
func (handler *Handler) Clear() {
	handler.mutex.Lock()
	handler.events = []*event.Event{}
	handler.mutex.Unlock()
}
296595
func (gc *Cfg) Clear() error {
	key := cfgGlobalPath
	return gc.StateDriver.ClearState(key)
}
805258
func (renderer *Renderer) Clear() error {
	return errorFromInt(int(
		C.SDL_RenderClear(renderer.cptr())))
}
686827
func (d *ConsulStateDriver) ClearState(key string) error {
	key = processKey(key)
	_, err := d.Client.KV().Delete(key, nil)
	return err
}
444888
func (g *Oper) Clear() error {
	key := operGlobalPath
	return g.StateDriver.ClearState(key)
}
37189
func (c *Container) Clear() {

	for c.next != nil {
		if c.next.length == 0 {
			if c.pool != nil {
				c.pool.Put(c.next)
			}
			c.next = nil
			break
		}
		s := c.next
		for s.next != nil {
			if s.next.length == 0 {
				if s.pool != nil {
					s.pool.Put(s.next)
				}
				s.next = nil
				break
			}
			s = s.next
			break
		}
		for k := num - 1; k >= 0; k-- {
			s.Delete(s.items[k].Key)
		}

		s.length = 0
		if s.pool != nil {
			s.pool.Put(s)
		}
	}

	for _, v := range c.items {
		v.Key = nil
		v.Value = nil
	}
	c.length = 0
	return
}
245844
func (c *InMemoryCache) Clear() {
	c.items.Range(func(key, _ interface{}) bool {
		c.items.Delete(key)
		return true
	})
}