// RefSet returns the set of refs that represent the same owner as keyID.
436033
func (o *Owner) RefSet(keyID string) SignerRefSet {
	if o == nil || len(o.blobByKeyID) == 0 {
		return nil
	}
	refs := o.blobByKeyID[keyID]
	if len(refs) == 0 {
		return nil
	}
	return refs
}
176392
func (s *SystemInfo) Set(name string, val string) {
	s.GetSet.Set(s, name, val)
}
148411
func BaseProofSet(u *keybase1.UserPlusKeysV2AllIncarnations) *ProofSet {
	proofs := []Proof{
		{Key: "keybase", Value: u.GetName()},
		{Key: "uid", Value: u.GetUID().String()},
	}
	for _, key := range u.Current.PGPKeys {
		proofs = append(proofs, Proof{Key: PGPAssertionKey, Value: key.Fingerprint.String()})
	}
	return NewProofSet(proofs)
}
848408
func (r *Redis) Set(key string, value interface{}) error {
	return r.Client.Set(key, convertToBytes(value), 0).Err()
}
104690
func (r *ShardedTTL) Set(tenantID, key string, value interface{}) error {
	r.Lock()
	defer r.Unlock()

	r.cache.Set(tenantID, key, value)
	_, ok := r.setAts[tenantID]
	if !ok {
		r.setAts[tenantID] = make(map[string]time.Time)
	}
	r.setAts[tenantID][key] = time.Now()
	return nil
}
966669
func (c *RefManager) SetRef(id ContainerID, ref *v1.ObjectReference) {
	c.Lock()
	defer c.Unlock()
	c.containerIDToRef[id] = ref
}
1190514
func (s *storeImpl) Set(key string, val interface{}) {
	s.mutex.Lock()
	defer s.mutex.Unlock()
	s.objects[key] = object{contents: val}
}
172283
func (s *Scanner) Set(k, v []byte, opset uint) bool {
	if !s.checkOpen() {
		return false
	}
	s.set = true
	s.key, s.val, s.err = s.cur.Get(k, v, opset)
	return s.err == nil
}
131238
func (m *MultiMap) KeySet() []interface{} {
	keys := make([]interface{}, len(m.m))
	count := 0
	for key := range m.m {
		keys[count] = key
		count++
	}
	return keys
}
206982
func (s *RedisMapStore) Set(key string, value interface{}, properties ...string) error {
	key, vmap, err := s.prepare(key, value, properties...)
	if err != nil {
		return err
	}
	if len(vmap) == 0 {
		return nil
	}
	return s.client.HMSet(key, vmap).Err()
}
1279482
func (b *Blob) StaticSetMergeSets() []blob.Ref {
	if b.Type() != "static-set" {
		return nil
	}

	s := make([]blob.Ref, 0, len(b.ss.MergeSets))
	for _, ref := range b.ss.MergeSets {
		if ref.Valid() {
			s = append(s, ref)
		}
	}
	return s
}
832249
func (m *lockingMap) Set(key string, val interface{}) {
	m.keyLocker.Lock(key)
	defer m.keyLocker.Unlock(key)

	m.lock.Lock()
	defer m.lock.Unlock()

	m.data[key] = val
}
193129
func (m *MapOfCharacterToGlyphIndex) Set(k rune, v uint) {
	m.keyIndexs[k] = len(m.Keys)
	m.Keys = append(m.Keys, k)
	m.Vals = append(m.Vals, v)
}
899282
func (r *Ref) Set(tx *Tx, val interface{}) interface{} {
	return tx.doSet(r, val)
}
912247
func Set(key string, value interface{}, args ...interface{}) error {
	return std.Set(key, value, args...)
}
190439
func (d *DotGit) Refs() ([]*plumbing.Reference, error) {
	var refs []*plumbing.Reference
	var seen = make(map[plumbing.ReferenceName]bool)
	if err := d.addRefsFromRefDir(&refs, seen); err != nil {
		return nil, err
	}

	if err := d.addRefsFromPackedRefs(&refs, seen); err != nil {
		return nil, err
	}

	if err := d.addRefFromHEAD(&refs); err != nil {
		return nil, err
	}

	return refs, nil
}
104214
func (rsc *ReplicaSetController) enqueueReplicaSet(obj interface{}) {
	key, err := controller.KeyFunc(obj)
	if err != nil {
		utilruntime.HandleError(fmt.Errorf("couldn't get key for object %+v: %v", obj, err))
		return
	}
	rsc.queue.Add(key)
}