// Implements atomicSetDeleter.
180636
func (ddb debugDB) SetNoLockSync(key []byte, value []byte) {
	fmt.Printf("%v.SetNoLockSync(%v, %v)\n", ddb.label,
		cmn.ColoredBytes(key, cmn.Yellow, cmn.Blue),
		cmn.ColoredBytes(value, cmn.Green, cmn.Blue))
	ddb.db.(atomicSetDeleter).SetNoLockSync(key, value)
}
795095
func (v *ValueChangePublisher) Set(value interface{}) {
	v.mutex.Lock()
	defer v.mutex.Unlock()
	v.value = value
	close(v.notify)
	v.notify = make(chan struct{})
}
884934
func (ab *AtomicBool) Set(newVal bool) {
	var i int32
	if newVal {
		i = 1
	}
	atomic.StoreInt32(&(ab.val), int32(i))
}
554524
func (l *HostStateListener) setExistingThreadOrShutdown(stateID string, data *ServiceState, containerExit <-chan time.Time) bool {
	l.mu.Lock()
	defer l.mu.Unlock()

	select {
	case <-l.shutdown:
		return false
	default:
		l.setExistingThread(stateID, data, containerExit)
	}

	return true
}
171093
func (s *Comment) SetDeleted(v bool) *Comment {
	s.Deleted = &v
	return s
}
1246744
func (c *SyncCollector) Set(k string, v interface{}) {
	c.rw.Lock()
	c.c.Set(k, v)
	c.rw.Unlock()
}
171264
func (opts *TransactionOptions) SetDeadlockDetect(value bool) {
	C.rocksdb_transaction_options_set_deadlock_detect(opts.c, boolToChar(value))
}
1179783
func (s *Bitset) SetAll() *Bitset {
	return s.unitOp(func(s *Bitset, i int) {
		s.set[i] = unitMax
	})
}
885050
func (s *ReplicaUpdate) SetDelete(v *DeleteReplicaAction) *ReplicaUpdate {
	s.Delete = v
	return s
}
860168
func (a *Astilectron) SetExecuter(e Executer) *Astilectron {
	a.executer = e
	return a
}
846614
func (s *MockStore) AtomicDelete(key string, previous *store.KVPair) (bool, error) {
	mData := s.db[key]
	if mData != nil && mData.Index != previous.LastIndex {
		return false, types.BadRequestErrorf("atomic delete failed due to mismatched Index")
	}
	return true, s.Delete(key)
}
651768
func (f *SecureStack) Set(ind int, d interface{}) {
	sz := f.Size()

	if ind >= sz {
		return
	}

	if ind < 0 {
		ind = sz - ind
		if ind < 0 {
			return
		}
	}

	f.lock.Lock()
	f.listeners[ind] = d
	f.lock.Unlock()
}
482964
func (me *TxsdRunTypeSequenceSequenceDataBlockSequenceFilesSequenceFileChecksumMethod) Set(s string) {
	(*xsdt.String)(me).Set(s)
}
1068403
func (s *MockStore) AtomicPut(key string, newValue []byte, previous *store.KVPair, options *store.WriteOptions) (bool, *store.KVPair, error) {
	mData := s.db[key]

	if previous == nil {
		if mData != nil {
			return false, nil, types.BadRequestErrorf("atomic put failed because key exists")
		} // Else OK.
	} else {
		if mData == nil {
			return false, nil, types.BadRequestErrorf("atomic put failed because key exists")
		}
		if mData != nil && mData.Index != previous.LastIndex {
			return false, nil, types.BadRequestErrorf("atomic put failed due to mismatched Index")
		} // Else OK.
	}
	err := s.Put(key, newValue, nil)
	if err != nil {
		return false, nil, err
	}
	return true, &store.KVPair{Key: key, Value: newValue, LastIndex: s.db[key].Index}, nil
}
522608
func (set *Set) Dispose() {
	set.lock.Lock()
	defer set.lock.Unlock()

	for k := range set.items {
		delete(set.items, k)
	}

	//this is so we don't hang onto any references
	for i := 0; i < len(set.flattened); i++ {
		set.flattened[i] = nil
	}

	set.flattened = set.flattened[:0]
	pool.Put(set)
}
951292
func (s *CrawlerMetrics) SetTablesDeleted(v int64) *CrawlerMetrics {
	s.TablesDeleted = &v
	return s
}
186783
func (ai *AtomicInt) GetAndSet(newValue int) int {
	res := int(atomic.SwapInt64(&ai.val, int64(newValue)))
	return res
}