// ClearAll turns off all LEDs of all modules
337663
func (a *MAX7219Driver) ClearAll() {
	for i := 1; i <= 8; i++ {
		a.All(byte(i), 0)
	}
}
831321
func (mem *memNamedMapping) Clear() {
	names := mem.ListAllNames()
	for _, item := range names {
		mem.removeNameIdxSync(item)
	}
}
80303
func (mongo *MongoDB) DeleteAll() error {
	_, err := mongo.Collection.RemoveAll(bson.M{})
	return err
}
658182
func (obj *Field) ClearAllButThis(ctx context.Context, softLock bool) (bool, error) {
	result := &struct {
		Return bool	`json:"qReturn"`
	} {}
	err := obj.rpc(ctx, "ClearAllButThis", result, softLock)
	return result.Return, err 
}
106545
func resetAll(cmd *cobra.Command, args []string) {
	ResetAll(config.DBDir(), config.P2P.AddrBookFile(), config.PrivValidatorKeyFile(),
		config.PrivValidatorStateFile(), logger)
}
456849
func (m *mapReact) DisableAll() {
	m.ro.Lock()
	for ms := range m.ma {
		m.ma[ms] = false
	}
	m.ro.Unlock()
}
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
}
1238539
func (r *keyring) RemoveAll() error {
	r.mu.Lock()
	defer r.mu.Unlock()
	if r.locked {
		return errLocked
	}

	r.keys = nil
	return nil
}
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)
}
76956
func (s *set) removeAll() int {
	ret := len(s.m)
	s.m = make(map[setElement]struct{})
	return ret
}
901962
func (l *Ledis) FlushAll() error {
	l.wLock.Lock()
	defer l.wLock.Unlock()

	return l.flushAll()
}
1363207
func (s *Session) ClearFlashes() {
	s.mu.Lock()
	for key := range s.flashes {
		delete(s.flashes, key)
	}
	s.mu.Unlock()
}
970698
func (d *Dialer) CloseAll() {
	d.mu.Lock()
	conns := d.conns
	d.conns = make(map[*closableConn]struct{})
	d.mu.Unlock()

	for conn := range conns {
		conn.Close()
	}
}
24656
func (h *nodeHeartbeater) clearAllHeartbeatTimers() error {
	h.heartbeatTimersLock.Lock()
	defer h.heartbeatTimersLock.Unlock()

	for _, t := range h.heartbeatTimers {
		t.Stop()
	}
	h.heartbeatTimers = nil
	return nil
}
1367867
func (b *Batch) Clear() {
	b.cont.Triangles.SetLen(0)
	b.cont.Dirty()
}
1043861
func (rgc *RasterGraphicContext) Clear() {
	width, height := rgc.img.Bounds().Dx(), rgc.img.Bounds().Dy()
	rgc.ClearRect(0, 0, width, height)
}
343835
func (list *List) ClearOptions() {
	length := len(list.options)
	diff := length - list.Index

	// Move to the last line.
	if diff != 0 {
		list.Cursor.MoveDown(diff)
	}

	list.Index = length

	// Erase options
	for list.Index != 0 {
		list.Index--
		list.Cursor.EraseCurrentLine()
		list.Cursor.MoveUp(1)
	}
}