// Clear removes all session key values but it keeps the session entry.
336802
func (db *Database) Clear(sid string) {
	keys := db.keys(sid)
	for _, key := range keys {
		db.redis.Delete(key)
	}
}
1210787
func (c *Cache) Clear() {
	c.Lock()
	defer c.Unlock()
	if c.onEvicted != nil {
		for _, ci := range c.cache {
			c.onEvicted(ci.itemID, ci.value)
		}
	}
	c.cache = make(map[string]*cachedItem)
	c.groups = make(map[string]map[string]struct{})
	c.lruIdx = c.lruIdx.Init()
	c.lruRefs = make(map[string]*list.Element)
	c.ttlIdx = c.ttlIdx.Init()
	c.ttlRefs = make(map[string]*list.Element)
}
1367867
func (b *Batch) Clear() {
	b.cont.Triangles.SetLen(0)
	b.cont.Dirty()
}
1084246
func (s *FeatureFlagSet) Clear() {
	s.Lock()
	defer s.Unlock()
	s.features = make(map[Feature]*featureSlot)
}
887478
func (s *CfgNetworkState) Clear() error {
	key := fmt.Sprintf(networkConfigPath, s.ID)
	return s.StateDriver.ClearState(key)
}
642958
func (set *TagKeysSet) Clear() {
	set.clear(set.keys[0])
	set.clear(set.keys[1])
	set.clear(set.tmp)
	set.i = 0
	set.keys[0] = set.keys[0][:0]
}
148939
func (r *AutoVLANCfgResource) Clear() error {
	key := fmt.Sprintf(vLANResourceConfigPath, r.ID)
	return r.StateDriver.ClearState(key)
}
564426
func Clear(c context.Context) context.Context {
	return context.WithValue(c, &pldKey, nil)
}
834725
func (deque *keyedDeque) Clear() {
	deque.Lock()
	defer deque.Unlock()

	deque.syncedList.Clear()
	deque.index = make(map[interface{}]*list.Element)
	deque.invertedIndex = make(map[*list.Element]interface{})
}
1367630
func (c *InMemoryCache) Clear() {
	c.mu.Lock()
	c.items = map[string]Thunk{}
	c.mu.Unlock()
}
996604
func (r *Request) Clear() {
	r.name = ""
	r.ip = ""
	r.localIP = ""
	r.port = ""
	r.localPort = ""
	r.family = 0
}
1320360
func (e *Element) Clear() error {
	e.lock.RLock()
	defer e.lock.RUnlock()

	var err error

	if !e.ready {
		return &ElementNotReadyErr{}
	}

	if e.nodeName == "textarea" {
		_, err = e.tab.DOM.SetNodeValue(e.id, "")
	} else if e.nodeName == "input" {
		_, err = e.tab.DOM.SetAttributeValue(e.id, "value", "")
	} else {
		err = &IncorrectElementTypeErr{ExpectedName: "textarea or input", NodeName: e.nodeName}
	}
	return err
}
892945
func (c *Cache) Clear() {
	c.mu.Lock()
	defer c.mu.Unlock()

	c.cache = make(map[string]cacheEntry)
	c.nlocker = locker.NewLocker()

}
934630
func (o *Options) Clear() {
	o.Name = ""
	o.Cron = ""
	o.Every = Duration{}
	o.Offset = nil
	o.Concurrency = nil
	o.Retry = nil
}
1277207
func (a *ActiveDevice) clear() error {
	a.Lock()
	defer a.Unlock()

	a.uv = keybase1.UserVersion{}
	a.deviceID = ""
	a.signingKey = nil
	a.encryptionKey = nil
	a.nistFactory = nil
	a.passphrase = nil
	a.provisioningKey = nil
	a.secretPromptCancelTimer.Reset()

	return nil
}
735783
func (s *EndpointGroupState) Clear() error {
	key := fmt.Sprintf(epGroupConfigPath, s.ID)
	return s.StateDriver.ClearState(key)
}
1305269
func (set *Set) Clear() {
	set.lock.Lock()

	set.items = map[interface{}]struct{}{}

	set.lock.Unlock()
}