// SetLevelFromString parses level from string and set parsed level
// (NOTE): set level to INFO if parse failed
964140
func SetLevelFromString(s string) logger.Level {
	level, _ := ParseLevel(s)
	glogger.SetLevel(level)
	return level
}
467316
func (t *Text) SetString(fs string, argv ...interface{}) {
	indices := []rune(fmt.Sprintf(fs, argv...))
	if t.MaxRuneCount > 0 && len(indices) > t.MaxRuneCount+1 {
		indices = indices[0:t.MaxRuneCount]
	}
	t.String = string(indices)

	// ebo, vbo data
	glfloat_size := int32(4)

	t.vboIndexCount = len(indices) * 4 * 2 * 2 // 4 indexes per rune (containing 2 position + 2 texture)
	t.eboIndexCount = len(indices) * 6         // each rune requires 6 triangle indices for a quad
	t.RuneCount = len(indices)
	t.vboData = make([]float32, t.vboIndexCount, t.vboIndexCount)
	t.eboData = make([]int32, t.eboIndexCount, t.eboIndexCount)

	// generate the basic vbo data and bounding box
	// center the vbo data around the orthographic (0,0) point
	t.X1 = gltext.Point{0, 0}
	t.X2 = gltext.Point{0, 0}
	t.makeBufferData(indices)
	t.centerTheData(t.getLowerLeft())

	if gltext.IsDebug {
		prefix := gltext.DebugPrefix()
		fmt.Printf("%s bounding box %v %v\n", prefix, t.X1, t.X2)
		fmt.Printf("%s text vbo data\n%v\n", prefix, t.vboData)
		fmt.Printf("%s text ebo data\n%v\n", prefix, t.eboData)
	}
	if len(indices) > 0 {
		// in the event that we have no data to draw dont bother here
		gl.BindVertexArray(t.vao)
		gl.BindBuffer(gl.ARRAY_BUFFER, t.vbo)
		gl.BufferData(
			gl.ARRAY_BUFFER, int(glfloat_size)*t.vboIndexCount, gl.Ptr(t.vboData), gl.DYNAMIC_DRAW)
		gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, t.ebo)
		gl.BufferData(
			gl.ELEMENT_ARRAY_BUFFER, int(glfloat_size)*t.eboIndexCount, gl.Ptr(t.eboData), gl.DYNAMIC_DRAW)
		gl.BindVertexArray(0)

		// possibly not necesssary?
		gl.BindBuffer(gl.ARRAY_BUFFER, 0)
		gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, 0)
	}

	// SetString can be called at anytime.  we want to make sure that if the user is updating the text,
	// the previous position will be maintained
	t.SetPosition(t.Position)
}
280965
func (f *File) SetString(in string, typ StringType) (err error) {
	s := C.CString(in)
	defer C.free(unsafe.Pointer(s))
	if C.sf_set_string(f.s, C.int(typ), s) != 0 {
		err = errors.New(C.GoString(C.sf_strerror(f.s)))
	}
	return
}
288914
func (s *HierarchyPath) SetLevelFour(v *HierarchyGroupSummary) *HierarchyPath {
	s.LevelFour = v
	return s
}
279784
func SetLogLevel(logLevel string) {
	level, err := log.ParseLevel(logLevel)
	errors.CheckError(err)
	log.SetLevel(level)
	if os.Getenv("FORCE_LOG_COLORS") == "1" {
		log.SetFormatter(&log.TextFormatter{ForceColors: true})
	}
}
1166555
func (blog *BLog) SetLevel(level LevelType) *BLog {
	blog.level = level
	return blog
}
314862
func (section *Section) SetString(name string, value string) {
	current, err := section.Get(name)

	// Exists just update the value/type
	if err == nil {
		current.UpdateValue(value)
	} else {
		section.Set(name, NewString(value))
	}
}
110320
func (s *LoggingOptionsPayload) SetLogLevel(v string) *LoggingOptionsPayload {
	s.LogLevel = &v
	return s
}
476027
func (l *intLogger) SetLevel(level Level) {
	atomic.StoreInt32(l.level, int32(level))
}
1099962
func (cl *CoLog) SetDefaultLevel(l Level) {
	cl.mu.Lock()
	defer cl.mu.Unlock()

	cl.defaultLevel = l
}
26215
func (s *HierarchyStructure) SetLevelFour(v *HierarchyLevel) *HierarchyStructure {
	s.LevelFour = v
	return s
}
817426
func (u *Unit) ValueFromString(str string) (*Value, error) {
	s := &Value{unit: u}

	if err := s.Set(str); err != nil {
		return nil, err
	}
	return s, nil
}
204649
func (c Context) SetString(z *Big, s string) (*Big, bool) {
	if _, ok := z.SetString(s); !ok {
		return nil, false
	}
	return c.Round(z), true
}
1207817
func SetLogLevel(ctx context.Context, lvl log.Level) {
	if logCtx, ok := ctx.(*lsc); ok {
		if lvl == logCtx.logger.Level {
			return
		}
		if logCtx.loggerInherited {
			parentLogger := logCtx.logger
			logCtx.logger = &log.Logger{
				Formatter: parentLogger.Formatter,
				Out:       parentLogger.Out,
				Hooks:     parentLogger.Hooks,
				Level:     lvl,
			}
			logCtx.loggerInherited = false
		}
	}
}
849056
func SetLevel(level Level) {
	l, err := parseLevel(level)
	if err != nil {
		fmt.Printf("%v", err)
	}

	std.mu.Lock()
	defer std.mu.Unlock()
	std.Level = l
}
1214766
func (logger *Logger) SetLevel(level Level) {
	atomic.StoreUint32((*uint32)(&logger.Level), uint32(level))
}
406922
func (a *ReplaySnapshotArgs) SetFromStep(fromStep int) *ReplaySnapshotArgs {
	a.FromStep = &fromStep
	return a
}