// Set: Set (and start) a new rollout strategy for this group.
482634
func (r *GroupRolloutService) Set(appId string, groupId string, rollout *Rollout) *GroupRolloutSetCall {
	c := &GroupRolloutSetCall{s: r.s, urlParams_: make(gensupport.URLParams)}
	c.appId = appId
	c.groupId = groupId
	c.rollout = rollout
	return c
}
373095
func (k *KinesisConsumer) Set(streamName, shardID, sequenceNumber string) error {
	if sequenceNumber == "" {
		return fmt.Errorf("sequence number should not be empty")
	}

	k.checkpointTex.Lock()
	k.checkpoints[sequenceNumber] = checkpoint{streamName: streamName, shardID: shardID}
	k.checkpointTex.Unlock()

	return nil
}
344300
func Set(ver *Version) error {
	// Run the set_version script.
	_, err := scripts.Run(scripts.ScriptNameSetVersion, ver.String())
	return err
}
149708
func (m *MemBytes) Set(value string) error {
	val, err := units.RAMInBytes(value)
	*m = MemBytes(val)
	return err
}
1107043
func (c Context) Set(z, x *Big) *Big {
	return c.Round(z.Copy(x))
}
905837
func (m *InstallMode) Set(value string) error {
	val := InstallMode(value)
	if err := ValidateInstallMode(val); err != nil {
		return err
	}
	*m = val
	return nil
}
812740
func Set(v interface{}, err error) (map[interface{}]bool, error) {
	if err != nil {
		return nil, err
	}

	vd, ok := v.(map[interface{}]bool)
	if ok {
		return vd, nil
	}

	return nil, newWrongTypeError(v, vd)
}
252249
func (d *CodeGenOptions) Set(optFns ...func(*CodeGenOptions)) {
	for _, fn := range optFns {
		fn(d)
	}
}
53178
func (sys *PolicySys) Set(bucketName string, policy policy.Policy) {
	sys.Lock()
	defer sys.Unlock()

	if policy.IsEmpty() {
		delete(sys.bucketPolicyMap, bucketName)
	} else {
		sys.bucketPolicyMap[bucketName] = policy
	}
}
842032
func (m *Map) Set(val *Package) {
	m.lock.Lock()
	defer m.lock.Unlock()

	m.jobs[val.ID] = val
}
700458
func (r *RedisStorer) Set(key, value string) error {
	return r.client.Set(key, value, r.maxAge).Err()
}
890719
func (r *raftLog) Set(k, v []byte) error {
	r.Lock()
	tx, err := r.conn.Begin(true)
	if err != nil {
		r.Unlock()
		return err
	}
	bucket := tx.Bucket(confBucket)
	err = bucket.Put(k, v)
	if err != nil {
		tx.Rollback()
	} else {
		err = tx.Commit()
	}
	r.Unlock()
	return err
}
943967
func (c *Client) Set(application string, options map[string]string) error {
	p := params.ApplicationSet{
		ApplicationName: application,
		Options:         options,
	}
	return c.facade.FacadeCall("Set", p, nil)
}
141243
func (m ConcurrentMap) Set(key string, value interface{}) {
	// Get map shard.
	shard := m.GetShard(key)
	shard.Lock()
	shard.items[key] = value
	shard.Unlock()
}
1025744
func (f *tokenFuture) Set(token string) *tokenFuture {
	f.m.Lock()
	defer f.m.Unlock()

	f.set = true
	f.token = token
	for _, w := range f.waiting {
		close(w)
	}
	f.waiting = nil
	return f
}
35520
func (m *MDBStore) Set(key []byte, val []byte) error {
	// Start write txn
	tx, dbis, err := m.startTxn(false, dbConf)
	if err != nil {
		return err
	}

	if err := tx.Put(dbis[0], key, val, 0); err != nil {
		tx.Abort()
		return err
	}
	return tx.Commit()
}
269420
func (m RoutingMechanismMap) Set(s string, mechanism Mechanism) {
	rmechanism, ok := mechanism.(RoutingMechanism)
	if !ok {
		log.ErrorLog("route/SET_MECHANISM",
			"Failed to cast to route layer mechanism")
		return
	}

	m[s] = rmechanism
}