// Remove removes a given item from the set
189395
func (s *Set) Remove(item interface{}) {
	s.lock.Lock()
	defer s.lock.Unlock()
	delete(s.items, item)
}
631923
func (b *FugaJSONBuilder) Remove(info *FugaPropertyInfo) *FugaJSONBuilder {
	delete(b._properties, info.fieldName)
	return b
}
249141
func (s Int64) Delete(items ...int64) {
	for _, item := range items {
		delete(s, item)
	}
}
1006245
func (q *graceTerminateRSList) remove(rs *listItem) bool {
	q.lock.Lock()
	defer q.lock.Unlock()

	uniqueRS := rs.String()
	if _, ok := q.list[uniqueRS]; ok {
		delete(q.list, uniqueRS)
		return true
	}
	return false
}
15424
func (l *ItemList) remove(e *ItemElement) *ItemElement {
	e.prev.next = e.next
	e.next.prev = e.prev
	e.next = nil // avoid memory leaks
	e.prev = nil // avoid memory leaks
	e.list = nil
	l.len--
	return e
}
812288
func (s Set) Delete(els ...string) Set {
	if s == nil {
		return s
	}

	for _, el := range els {
		delete(s, el)
	}

	return s
}
941232
func (ref *Reference) Remove() error {
	_, err := ref.invokeRequest(http.MethodDelete, nil)
	if err != nil {
		return err
	}
	return nil
}
76956
func (s *set) removeAll() int {
	ret := len(s.m)
	s.m = make(map[setElement]struct{})
	return ret
}
611018
func (s *RankedSet) Delete(item Item) Item {
	key := item.Key()
	value, ok := s.set[key]
	if !ok {
		return nil
	}

	s.rank.Delete(value) // should always return the same data as value (non-nil)
	delete(s.set, key)

	return value.item
}
1222739
func (set *Set) Remove(items ...interface{}) {
	set.lock.Lock()
	defer set.lock.Unlock()

	set.flattened = nil
	for _, item := range items {
		delete(set.items, item)
	}
}
162935
func (c *changer) Remove() error {
	if c.err != nil {
		return c.err
	}
	return c.node.remove()
}
467597
func (c *Cache) Remove(u interface{}) (err error) {

	return c.removeNotify(u, false)
}
264913
func (m *Model) Remove() {
	for _, dir := range m.dirs {
		_ = os.RemoveAll(dir)
	}
}
737180
func (s *Set) Remove(key interface{}) (ok bool) {
	_, ok = s.skiplist.Delete(key)
	return ok
}
1226146
func (c *ARC) Remove(key interface{}) bool {
	c.mu.Lock()
	defer c.mu.Unlock()

	return c.remove(key)
}
1287350
func (s Byte) Delete(items ...byte) {
	for _, item := range items {
		delete(s, item)
	}
}
529578
func (s *Set) Remove() error {
	err := (*bbolt.DB)(s.db).Update(func(tx *bbolt.Tx) error {
		return tx.DeleteBucket(s.name)
	})
	// Mark as removed by setting the name to nil
	s.name = nil
	return err
}