// SetRaidLevel sets the RaidLevel field's value.
554278
func (s *VolumeConfiguration) SetRaidLevel(v int64) *VolumeConfiguration {
	s.RaidLevel = &v
	return s
}
627293
func SetLevel(module string, level api.Level) {
	rwmutex.Lock()
	defer rwmutex.Unlock()
	moduleLevels.SetLevel(module, level)
}
890062
func (s *ReplicationJob) SetServerId(v string) *ReplicationJob {
	s.ServerId = &v
	return s
}
925595
func SetLevel(re *regexp.Regexp, level LogLevel) {
	DefaultLoggerCollection.SetLevel(re, level)
}
594389
func (l *Logger) SetLevel(v string) {
	switch v {
	case "debug", "DEBUG":
		l.Level = logrus.DebugLevel
	case "info", "INFO":
		l.Level = logrus.InfoLevel
	case "warning", "WARNING":
		l.Level = logrus.WarnLevel
	case "error", "ERROR":
		l.Level = logrus.ErrorLevel
	case "fatal", "FATAL":
		l.Level = logrus.FatalLevel
	case "panic", "PANIC":
		l.Level = logrus.PanicLevel
	}
}
1121249
func SetLevel(level string) {
	lvl, err := log.ParseLevel(level)
	if err != nil {
		Fatal(fmt.Sprintf(`not a valid level: "%s"`, level))
	}
	log.SetLevel(lvl)
}
1355611
func (a *Webhook) SetServiceResolver(sr webhook.ServiceResolver) {
	a.clientManager.SetServiceResolver(sr)
}
372168
func (client *RenderingControl2) SetVolume(InstanceID uint32, Channel string, DesiredVolume uint16) (err error) {
	// Request structure.
	request := &struct {
		InstanceID    string
		Channel       string
		DesiredVolume string
	}{}
	// BEGIN Marshal arguments into request.

	if request.InstanceID, err = soap.MarshalUi4(InstanceID); err != nil {
		return
	}
	if request.Channel, err = soap.MarshalString(Channel); err != nil {
		return
	}
	if request.DesiredVolume, err = soap.MarshalUi2(DesiredVolume); err != nil {
		return
	}
	// END Marshal arguments into request.

	// Response structure.
	response := interface{}(nil)

	// Perform the SOAP call.
	if err = client.SOAPClient.PerformAction(URN_RenderingControl_2, "SetVolume", request, response); err != nil {
		return
	}

	// BEGIN Unmarshal arguments from response.

	// END Unmarshal arguments from response.
	return
}
417739
func (s *DescribeSnapshotScheduleOutput) SetVolumeARN(v string) *DescribeSnapshotScheduleOutput {
	s.VolumeARN = &v
	return s
}
88373
func SetLevel(l Level) {
	if logger, ok := Log.(*Logger); ok {
		logger.Level = l
	}
}
1166555
func (blog *BLog) SetLevel(level LevelType) *BLog {
	blog.level = level
	return blog
}
898935
func (wr *Wrangler) SetShardIsMasterServing(ctx context.Context, keyspace, shard string, isMasterServing bool) (err error) {
	// lock the keyspace to not conflict with resharding operations
	ctx, unlock, lockErr := wr.ts.LockKeyspace(ctx, keyspace, fmt.Sprintf("SetShardIsMasterServing(%v,%v,%v)", keyspace, shard, isMasterServing))
	if lockErr != nil {
		return lockErr
	}
	defer unlock(&err)

	// and update the shard
	_, err = wr.ts.UpdateShardFields(ctx, keyspace, shard, func(si *topo.ShardInfo) error {
		si.IsMasterServing = isMasterServing
		return nil
	})
	return err
}
388980
func (s *VolumeInfo) SetVolumeARN(v string) *VolumeInfo {
	s.VolumeARN = &v
	return s
}
1108461
func (l *Logger) SetLevel(level Level) *Logger {
	l.mu.Lock()
	defer l.mu.Unlock()
	if level > DebugLevel {
		panic(gear.Err.WithMsg("invalid logger level"))
	}
	l.l = level
	return l
}
31585
func (lr *logRegistry) SetLevel(logger, level string) error {
	lvl, err := logrus.ParseLevel(level)
	if err != nil {
		return err
	}
	if logger == "default" {
		lr.defaultLevel = lvl
		return nil
	}
	lr.logLevels[logger] = lvl
	logVal := lr.getLoggerFromMapping(logger)
	if logVal != nil {
		defaultLogger.Debugf("setting logger level: %v -> %v", logVal.GetName(), lvl.String())
		return setLevel(logVal, lvl)
	}
	return nil
}
1020364
func (as *Step) SetNestLevel(l int) bool {
	if as.level == l {
		return false
	}
	as.level = l

	// Attach this step to the correct parent step based on nest level. Ascend
	// up the previously-declared steps.
	var nestParent *Step
	for prev := as.prevStep; prev != nil; prev = prev.prevStep {
		if prev.level < l {
			nestParent = prev
			break
		}
	}
	if nestParent == nil || nestParent == as.parent {
		return true
	}
	nestParent.appendSubstep(as)
	return true
}
1091224
func (s *StorediSCSIVolume) SetVolumeARN(v string) *StorediSCSIVolume {
	s.VolumeARN = &v
	return s
}