// Returns the calculated value of a variable.
504986
func (obj *Variable) GetContent(ctx context.Context) (*AlfaNumString, error) {
	result := &struct {
		Content *AlfaNumString	`json:"qContent"`
	} {}
	err := obj.rpc(ctx, "GetContent", result)
	return result.Content, err 
}
664178
func readVariableValueLength(source []byte, offset ValueLength, reverse bool) ValueLength {
	length := ValueLength(0)
	p := uint(0)
	for {
		v := ValueLength(source[offset])
		length += (v & 0x7f) << p
		p += 7
		if reverse {
			offset--
		} else {
			offset++
		}
		if v&0x80 == 0 {
			break
		}
	}
	return length
}
1061017
func (c *Float) Get() float64 {
	return math.Float64frombits(atomic.LoadUint64(&c.currentVal))
}
1098521
func (f Float32) Get() (float32, error) {
	if !f.Present() {
		var zero float32
		return zero, errors.New("value not present")
	}
	return *f.value, nil
}
447119
func (v Float32) Get(deflt float32) float32 {
	if !v.Defined {
		return deflt
	}
	return v.V
}
1248099
func (_m *RequesterVariadic) Get(values ...string) bool {
	_va := make([]interface{}, len(values))
	for _i := range values {
		_va[_i] = values[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 bool
	if rf, ok := ret.Get(0).(func(...string) bool); ok {
		r0 = rf(values...)
	} else {
		r0 = ret.Get(0).(bool)
	}

	return r0
}
640986
func (v *variable) intValue() int {
	i, err := strconv.Atoi(v.value)
	if err != nil {
		panic("unexpected value " + v.value + " for int ")
	}
	return i
}
1050123
func (v Int) Get(deflt int) int {
	if !v.Defined {
		return deflt
	}
	return v.V
}
1046035
func getUintEnvVar(envVar string, def *uint) *uint {
	if strVal := os.Getenv(envVar); strVal != "" {
		if parsedVal, err := strconv.ParseUint(strVal, 10, 16); err == nil {
			val := uint(parsedVal)
			return &val
		}
	}
	return def
}
202669
func (s *SHA1Reporter) Var() expvar.Var {
	s.loadFileInfo()
	return expvar.Func(func() interface{} {
		return s.Fi
	})
}
1313376
func (c Complex128) Get() (complex128, error) {
	if !c.Present() {
		var zero complex128
		return zero, errors.New("value not present")
	}
	return *c.value, nil
}
793964
func GetRealValue(val *reflect.Value) interface{} {
	if val == nil {
		return nil
	}
	switch val.Kind() {
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		return val.Int()
	case reflect.String:
		return val.String()
	case reflect.Bool:
		return val.Bool()
	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
		return val.Uint()
	case reflect.Float32, reflect.Float64:
		return val.Float()
	default:
		return nil
	}
}
194393
func (ln *line) isVariable() bool {
	if !ln.isTopIndent() {
		return false
	}

	_, _, err := variableNV(ln)

	return err == nil
}
391608
func getVar(envVal string, def string) string {
	var ret string
	ret = os.Getenv(envVal)
	if ret == "" {
		ret = def
	}
	return ret
}
782885
func (t Times) GetValue(index int) float64 {
	return util.Time.ToFloat64(t[index])
}
1024229
func Var(inReal []float64, inTimePeriod int) []float64 {

	outReal := make([]float64, len(inReal))

	nbInitialElementNeeded := inTimePeriod - 1
	startIdx := nbInitialElementNeeded
	periodTotal1 := 0.0
	periodTotal2 := 0.0
	trailingIdx := startIdx - nbInitialElementNeeded
	i := trailingIdx
	if inTimePeriod > 1 {
		for i < startIdx {
			tempReal := inReal[i]
			periodTotal1 += tempReal
			tempReal *= tempReal
			periodTotal2 += tempReal
			i++
		}
	}
	outIdx := startIdx
	for ok := true; ok; {
		tempReal := inReal[i]
		periodTotal1 += tempReal
		tempReal *= tempReal
		periodTotal2 += tempReal
		meanValue1 := periodTotal1 / float64(inTimePeriod)
		meanValue2 := periodTotal2 / float64(inTimePeriod)
		tempReal = inReal[trailingIdx]
		periodTotal1 -= tempReal
		tempReal *= tempReal
		periodTotal2 -= tempReal
		outReal[outIdx] = meanValue2 - meanValue1*meanValue1
		i++
		trailingIdx++
		outIdx++
		ok = i < len(inReal)
	}
	return outReal
}
815118
func (a Float64A) Get(vals ...interface{}) (val float64) {
	v := get(a(0).arg(), vals)
	switch v := v.(type) {
	case *float64:
		return *v
	case float64:
		return v
	}
	return
}