aboutsummaryrefslogtreecommitdiffstats
path: root/Godeps/_workspace/src/github.com/obscuren/otto/value.go
diff options
context:
space:
mode:
authorzsfelfoldi <zsfelfoldi@gmail.com>2015-03-20 20:22:01 +0800
committerzsfelfoldi <zsfelfoldi@gmail.com>2015-03-20 20:22:01 +0800
commit8324b683b4e557e6c5c9d572d01f933b3e074185 (patch)
tree8c6a8c34d87f808c3979875642d4ca38844ad22d /Godeps/_workspace/src/github.com/obscuren/otto/value.go
parent91f9f355b2e334214e38e1827c624cdcc23c5130 (diff)
downloadgo-tangerine-8324b683b4e557e6c5c9d572d01f933b3e074185.tar
go-tangerine-8324b683b4e557e6c5c9d572d01f933b3e074185.tar.gz
go-tangerine-8324b683b4e557e6c5c9d572d01f933b3e074185.tar.bz2
go-tangerine-8324b683b4e557e6c5c9d572d01f933b3e074185.tar.lz
go-tangerine-8324b683b4e557e6c5c9d572d01f933b3e074185.tar.xz
go-tangerine-8324b683b4e557e6c5c9d572d01f933b3e074185.tar.zst
go-tangerine-8324b683b4e557e6c5c9d572d01f933b3e074185.zip
using robertkrimen/otto, godeps updated
Diffstat (limited to 'Godeps/_workspace/src/github.com/obscuren/otto/value.go')
-rw-r--r--Godeps/_workspace/src/github.com/obscuren/otto/value.go956
1 files changed, 0 insertions, 956 deletions
diff --git a/Godeps/_workspace/src/github.com/obscuren/otto/value.go b/Godeps/_workspace/src/github.com/obscuren/otto/value.go
deleted file mode 100644
index 5944126fd..000000000
--- a/Godeps/_workspace/src/github.com/obscuren/otto/value.go
+++ /dev/null
@@ -1,956 +0,0 @@
-package otto
-
-import (
- "fmt"
- "math"
- "reflect"
- "strconv"
- "unicode/utf16"
-)
-
-type _valueType int
-
-const (
- valueEmpty _valueType = iota
- valueNull
- valueUndefined
- valueNumber
- valueString
- valueBoolean
- valueObject
- valueResult
- valueReference
-)
-
-// Value is the representation of a JavaScript value.
-type Value struct {
- _valueType
- value interface{}
-}
-
-// ToValue will convert an interface{} value to a value digestible by otto/JavaScript
-// This function will not work for advanced types (struct, map, slice/array, etc.) and
-// you probably should not use it.
-//
-// ToValue may be deprecated and removed in the near future.
-//
-// Try Otto.ToValue for a replacement.
-func ToValue(value interface{}) (Value, error) {
- result := UndefinedValue()
- err := catchPanic(func() {
- result = toValue(value)
- })
- return result, err
-}
-
-// Empty
-
-func emptyValue() Value {
- return Value{_valueType: valueEmpty}
-}
-
-func (value Value) isEmpty() bool {
- return value._valueType == valueEmpty
-}
-
-// Undefined
-
-// UndefinedValue will return a Value representing undefined.
-func UndefinedValue() Value {
- return Value{_valueType: valueUndefined}
-}
-
-// IsDefined will return false if the value is undefined, and true otherwise.
-func (value Value) IsDefined() bool {
- return value._valueType != valueUndefined
-}
-
-// IsUndefined will return true if the value is undefined, and false otherwise.
-func (value Value) IsUndefined() bool {
- return value._valueType == valueUndefined
-}
-
-// NullValue will return a Value representing null.
-func NullValue() Value {
- return Value{_valueType: valueNull}
-}
-
-// IsNull will return true if the value is null, and false otherwise.
-func (value Value) IsNull() bool {
- return value._valueType == valueNull
-}
-
-// ---
-
-func (value Value) isCallable() bool {
- switch value := value.value.(type) {
- case *_object:
- return value.functionValue().call != nil
- }
- return false
-}
-
-func (value Value) isResult() bool {
- return value._valueType == valueResult
-}
-
-func (value Value) isReference() bool {
- return value._valueType == valueReference
-}
-
-// Call the value as a function with the given this value and argument list and
-// return the result of invocation. It is essentially equivalent to:
-//
-// value.apply(thisValue, argumentList)
-//
-// An undefined value and an error will result if:
-//
-// 1. There is an error during conversion of the argument list
-// 2. The value is not actually a function
-// 3. An (uncaught) exception is thrown
-//
-func (value Value) Call(this Value, argumentList ...interface{}) (Value, error) {
- result := UndefinedValue()
- err := catchPanic(func() {
- result = value.call(this, argumentList...)
- })
- return result, err
-}
-
-func (value Value) call(this Value, argumentList ...interface{}) Value {
- switch function := value.value.(type) {
- case *_object:
- return function.Call(this, argumentList...)
- }
- panic(newTypeError())
-}
-
-func (value Value) constructSafe(this Value, argumentList ...interface{}) (Value, error) {
- result := UndefinedValue()
- err := catchPanic(func() {
- result = value.construct(this, argumentList...)
- })
- return result, err
-}
-
-func (value Value) construct(this Value, argumentList ...interface{}) Value {
- switch function := value.value.(type) {
- case *_object:
- return function.Construct(this, argumentList...)
- }
- panic(newTypeError())
-}
-
-// IsPrimitive will return true if value is a primitive (any kind of primitive).
-func (value Value) IsPrimitive() bool {
- return !value.IsObject()
-}
-
-// IsBoolean will return true if value is a boolean (primitive).
-func (value Value) IsBoolean() bool {
- return value._valueType == valueBoolean
-}
-
-// IsNumber will return true if value is a number (primitive).
-func (value Value) IsNumber() bool {
- return value._valueType == valueNumber
-}
-
-// IsNaN will return true if value is NaN (or would convert to NaN).
-func (value Value) IsNaN() bool {
- switch value := value.value.(type) {
- case float64:
- return math.IsNaN(value)
- case float32:
- return math.IsNaN(float64(value))
- case int, int8, int32, int64:
- return false
- case uint, uint8, uint32, uint64:
- return false
- }
-
- return math.IsNaN(toFloat(value))
-}
-
-// IsString will return true if value is a string (primitive).
-func (value Value) IsString() bool {
- return value._valueType == valueString
-}
-
-// IsObject will return true if value is an object.
-func (value Value) IsObject() bool {
- return value._valueType == valueObject
-}
-
-// IsFunction will return true if value is a function.
-func (value Value) IsFunction() bool {
- if value._valueType != valueObject {
- return false
- }
- return value.value.(*_object).class == "Function"
-}
-
-// Class will return the class string of the value or the empty string if value is not an object.
-//
-// The return value will (generally) be one of:
-//
-// Object
-// Function
-// Array
-// String
-// Number
-// Boolean
-// Date
-// RegExp
-//
-func (value Value) Class() string {
- if value._valueType != valueObject {
- return ""
- }
- return value.value.(*_object).class
-}
-
-func (value Value) isArray() bool {
- if value._valueType != valueObject {
- return false
- }
- return isArray(value.value.(*_object))
-}
-
-func (value Value) isStringObject() bool {
- if value._valueType != valueObject {
- return false
- }
- return value.value.(*_object).class == "String"
-}
-
-func (value Value) isBooleanObject() bool {
- if value._valueType != valueObject {
- return false
- }
- return value.value.(*_object).class == "Boolean"
-}
-
-func (value Value) isNumberObject() bool {
- if value._valueType != valueObject {
- return false
- }
- return value.value.(*_object).class == "Number"
-}
-
-func (value Value) isDate() bool {
- if value._valueType != valueObject {
- return false
- }
- return value.value.(*_object).class == "Date"
-}
-
-func (value Value) isRegExp() bool {
- if value._valueType != valueObject {
- return false
- }
- return value.value.(*_object).class == "RegExp"
-}
-
-func (value Value) isError() bool {
- if value._valueType != valueObject {
- return false
- }
- return value.value.(*_object).class == "Error"
-}
-
-// ---
-
-func toValue_reflectValuePanic(value interface{}, kind reflect.Kind) {
- switch kind {
- case reflect.Struct:
- panic(newTypeError("Invalid value (struct): Missing runtime: %v (%T)", value, value))
- case reflect.Map:
- panic(newTypeError("Invalid value (map): Missing runtime: %v (%T)", value, value))
- case reflect.Slice:
- panic(newTypeError("Invalid value (slice): Missing runtime: %v (%T)", value, value))
- }
-}
-
-func toValue(value interface{}) Value {
- switch value := value.(type) {
- case Value:
- return value
- case bool:
- return Value{valueBoolean, value}
- case int:
- return Value{valueNumber, value}
- case int8:
- return Value{valueNumber, value}
- case int16:
- return Value{valueNumber, value}
- case int32:
- return Value{valueNumber, value}
- case int64:
- return Value{valueNumber, value}
- case uint:
- return Value{valueNumber, value}
- case uint8:
- return Value{valueNumber, value}
- case uint16:
- return Value{valueNumber, value}
- case uint32:
- return Value{valueNumber, value}
- case uint64:
- return Value{valueNumber, value}
- case float32:
- return Value{valueNumber, float64(value)}
- case float64:
- return Value{valueNumber, value}
- case []uint16:
- return Value{valueString, value}
- case string:
- return Value{valueString, value}
- // A rune is actually an int32, which is handled above
- case *_object:
- return Value{valueObject, value}
- case *Object:
- return Value{valueObject, value.object}
- case Object:
- return Value{valueObject, value.object}
- case _reference: // reference is an interface (already a pointer)
- return Value{valueReference, value}
- case _result:
- return Value{valueResult, value}
- case nil:
- // TODO Ugh.
- return UndefinedValue()
- case reflect.Value:
- for value.Kind() == reflect.Ptr {
- // We were given a pointer, so we'll drill down until we get a non-pointer
- //
- // These semantics might change if we want to start supporting pointers to values transparently
- // (It would be best not to depend on this behavior)
- // FIXME: UNDEFINED
- if value.IsNil() {
- return UndefinedValue()
- }
- value = value.Elem()
- }
- switch value.Kind() {
- case reflect.Bool:
- return Value{valueBoolean, bool(value.Bool())}
- case reflect.Int:
- return Value{valueNumber, int(value.Int())}
- case reflect.Int8:
- return Value{valueNumber, int8(value.Int())}
- case reflect.Int16:
- return Value{valueNumber, int16(value.Int())}
- case reflect.Int32:
- return Value{valueNumber, int32(value.Int())}
- case reflect.Int64:
- return Value{valueNumber, int64(value.Int())}
- case reflect.Uint:
- return Value{valueNumber, uint(value.Uint())}
- case reflect.Uint8:
- return Value{valueNumber, uint8(value.Uint())}
- case reflect.Uint16:
- return Value{valueNumber, uint16(value.Uint())}
- case reflect.Uint32:
- return Value{valueNumber, uint32(value.Uint())}
- case reflect.Uint64:
- return Value{valueNumber, uint64(value.Uint())}
- case reflect.Float32:
- return Value{valueNumber, float32(value.Float())}
- case reflect.Float64:
- return Value{valueNumber, float64(value.Float())}
- case reflect.String:
- return Value{valueString, string(value.String())}
- default:
- toValue_reflectValuePanic(value.Interface(), value.Kind())
- }
- default:
- return toValue(reflect.ValueOf(value))
- }
- panic(newTypeError("Invalid value: Unsupported: %v (%T)", value, value))
-}
-
-// String will return the value as a string.
-//
-// This method will make return the empty string if there is an error.
-func (value Value) String() string {
- result := ""
- catchPanic(func() {
- result = value.toString()
- })
- return result
-}
-
-func (value Value) toBoolean() bool {
- return toBoolean(value)
-}
-
-func (value Value) isTrue() bool {
- return toBoolean(value)
-}
-
-// ToBoolean will convert the value to a boolean (bool).
-//
-// ToValue(0).ToBoolean() => false
-// ToValue("").ToBoolean() => false
-// ToValue(true).ToBoolean() => true
-// ToValue(1).ToBoolean() => true
-// ToValue("Nothing happens").ToBoolean() => true
-//
-// If there is an error during the conversion process (like an uncaught exception), then the result will be false and an error.
-func (value Value) ToBoolean() (bool, error) {
- result := false
- err := catchPanic(func() {
- result = toBoolean(value)
- })
- return result, err
-}
-
-func (value Value) toNumber() Value {
- return toNumber(value)
-}
-
-func (value Value) toFloat() float64 {
- return toFloat(value)
-}
-
-// ToFloat will convert the value to a number (float64).
-//
-// ToValue(0).ToFloat() => 0.
-// ToValue(1.1).ToFloat() => 1.1
-// ToValue("11").ToFloat() => 11.
-//
-// If there is an error during the conversion process (like an uncaught exception), then the result will be 0 and an error.
-func (value Value) ToFloat() (float64, error) {
- result := float64(0)
- err := catchPanic(func() {
- result = toFloat(value)
- })
- return result, err
-}
-
-// ToInteger will convert the value to a number (int64).
-//
-// ToValue(0).ToInteger() => 0
-// ToValue(1.1).ToInteger() => 1
-// ToValue("11").ToInteger() => 11
-//
-// If there is an error during the conversion process (like an uncaught exception), then the result will be 0 and an error.
-func (value Value) ToInteger() (int64, error) {
- result := int64(0)
- err := catchPanic(func() {
- result = toInteger(value).value
- })
- return result, err
-}
-
-func (value Value) toString() string {
- return toString(value)
-}
-
-// ToString will convert the value to a string (string).
-//
-// ToValue(0).ToString() => "0"
-// ToValue(false).ToString() => "false"
-// ToValue(1.1).ToString() => "1.1"
-// ToValue("11").ToString() => "11"
-// ToValue('Nothing happens.').ToString() => "Nothing happens."
-//
-// If there is an error during the conversion process (like an uncaught exception), then the result will be the empty string ("") and an error.
-func (value Value) ToString() (string, error) {
- result := ""
- err := catchPanic(func() {
- result = toString(value)
- })
- return result, err
-}
-
-func (value Value) _object() *_object {
- switch value := value.value.(type) {
- case *_object:
- return value
- }
- return nil
-}
-
-// Object will return the object of the value, or nil if value is not an object.
-//
-// This method will not do any implicit conversion. For example, calling this method on a string primitive value will not return a String object.
-func (value Value) Object() *Object {
- switch object := value.value.(type) {
- case *_object:
- return _newObject(object, value)
- }
- return nil
-}
-
-func (value Value) reference() _reference {
- switch value := value.value.(type) {
- case _reference:
- return value
- }
- return nil
-}
-
-var (
- __NaN__ float64 = math.NaN()
- __PositiveInfinity__ float64 = math.Inf(+1)
- __NegativeInfinity__ float64 = math.Inf(-1)
- __PositiveZero__ float64 = 0
- __NegativeZero__ float64 = math.Float64frombits(0 | (1 << 63))
-)
-
-func positiveInfinity() float64 {
- return __PositiveInfinity__
-}
-
-func negativeInfinity() float64 {
- return __NegativeInfinity__
-}
-
-func positiveZero() float64 {
- return __PositiveZero__
-}
-
-func negativeZero() float64 {
- return __NegativeZero__
-}
-
-// NaNValue will return a value representing NaN.
-//
-// It is equivalent to:
-//
-// ToValue(math.NaN())
-//
-func NaNValue() Value {
- return Value{valueNumber, __NaN__}
-}
-
-func positiveInfinityValue() Value {
- return Value{valueNumber, __PositiveInfinity__}
-}
-
-func negativeInfinityValue() Value {
- return Value{valueNumber, __NegativeInfinity__}
-}
-
-func positiveZeroValue() Value {
- return Value{valueNumber, __PositiveZero__}
-}
-
-func negativeZeroValue() Value {
- return Value{valueNumber, __NegativeZero__}
-}
-
-// TrueValue will return a value representing true.
-//
-// It is equivalent to:
-//
-// ToValue(true)
-//
-func TrueValue() Value {
- return Value{valueBoolean, true}
-}
-
-// FalseValue will return a value representing false.
-//
-// It is equivalent to:
-//
-// ToValue(false)
-//
-func FalseValue() Value {
- return Value{valueBoolean, false}
-}
-
-func sameValue(x Value, y Value) bool {
- if x._valueType != y._valueType {
- return false
- }
- result := false
- switch x._valueType {
- case valueUndefined, valueNull:
- result = true
- case valueNumber:
- x := x.toFloat()
- y := y.toFloat()
- if math.IsNaN(x) && math.IsNaN(y) {
- result = true
- } else {
- result = x == y
- if result && x == 0 {
- // Since +0 != -0
- result = math.Signbit(x) == math.Signbit(y)
- }
- }
- case valueString:
- result = x.toString() == y.toString()
- case valueBoolean:
- result = x.toBoolean() == y.toBoolean()
- case valueObject:
- result = x._object() == y._object()
- default:
- panic(hereBeDragons())
- }
-
- return result
-}
-
-func strictEqualityComparison(x Value, y Value) bool {
- if x._valueType != y._valueType {
- return false
- }
- result := false
- switch x._valueType {
- case valueUndefined, valueNull:
- result = true
- case valueNumber:
- x := x.toFloat()
- y := y.toFloat()
- if math.IsNaN(x) && math.IsNaN(y) {
- result = false
- } else {
- result = x == y
- }
- case valueString:
- result = x.toString() == y.toString()
- case valueBoolean:
- result = x.toBoolean() == y.toBoolean()
- case valueObject:
- result = x._object() == y._object()
- default:
- panic(hereBeDragons())
- }
-
- return result
-}
-
-// Export will attempt to convert the value to a Go representation
-// and return it via an interface{} kind.
-//
-// WARNING: The interface function will be changing soon to:
-//
-// Export() interface{}
-//
-// If a reasonable conversion is not possible, then the original
-// result is returned.
-//
-// undefined -> otto.Value (UndefinedValue())
-// null -> interface{}(nil)
-// boolean -> bool
-// number -> A number type (int, float32, uint64, ...)
-// string -> string
-// Array -> []interface{}
-// Object -> map[string]interface{}
-//
-func (self Value) Export() (interface{}, error) {
- return self.export(), nil
-}
-
-func (self Value) export() interface{} {
-
- switch self._valueType {
- case valueUndefined:
- return nil
- case valueNull:
- return nil
- case valueNumber, valueBoolean:
- return self.value
- case valueString:
- switch value := self.value.(type) {
- case string:
- return value
- case []uint16:
- return string(utf16.Decode(value))
- }
- case valueObject:
- object := self._object()
- switch value := object.value.(type) {
- case *_goStructObject:
- return value.value.Interface()
- case *_goMapObject:
- return value.value.Interface()
- case *_goArrayObject:
- return value.value.Interface()
- case *_goSliceObject:
- return value.value.Interface()
- }
- if object.class == "Array" {
- result := make([]interface{}, 0)
- lengthValue := object.get("length")
- length := lengthValue.value.(uint32)
- for index := uint32(0); index < length; index += 1 {
- name := strconv.FormatInt(int64(index), 10)
- if !object.hasProperty(name) {
- continue
- }
- value := object.get(name)
- result = append(result, value.export())
- }
- return result
- } else {
- result := make(map[string]interface{})
- // TODO Should we export everything? Or just what is enumerable?
- object.enumerate(false, func(name string) bool {
- value := object.get(name)
- if value.IsDefined() {
- result[name] = value.export()
- }
- return true
- })
- return result
- }
- }
-
- return self
-}
-
-func (self Value) evaluateBreakContinue(labels []string) _resultKind {
- result := self.value.(_result)
- if result.kind == resultBreak || result.kind == resultContinue {
- for _, label := range labels {
- if label == result.target {
- return result.kind
- }
- }
- }
- return resultReturn
-}
-
-func (self Value) evaluateBreak(labels []string) _resultKind {
- result := self.value.(_result)
- if result.kind == resultBreak {
- for _, label := range labels {
- if label == result.target {
- return result.kind
- }
- }
- }
- return resultReturn
-}
-
-func (self Value) exportNative() interface{} {
-
- switch self._valueType {
- case valueUndefined:
- return self
- case valueNull:
- return nil
- case valueNumber, valueBoolean:
- return self.value
- case valueString:
- switch value := self.value.(type) {
- case string:
- return value
- case []uint16:
- return string(utf16.Decode(value))
- }
- case valueObject:
- object := self._object()
- switch value := object.value.(type) {
- case *_goStructObject:
- return value.value.Interface()
- case *_goMapObject:
- return value.value.Interface()
- case *_goArrayObject:
- return value.value.Interface()
- case *_goSliceObject:
- return value.value.Interface()
- }
- }
-
- return self
-}
-
-func (value Value) toReflectValue(kind reflect.Kind) (reflect.Value, error) {
- switch kind {
- case reflect.Bool:
- return reflect.ValueOf(value.toBoolean()), nil
- case reflect.Int:
- // We convert to float64 here because converting to int64 will not tell us
- // if a value is outside the range of int64
- tmp := toIntegerFloat(value)
- if tmp < float_minInt || tmp > float_maxInt {
- return reflect.Value{}, fmt.Errorf("RangeError: %d (%v) to int", tmp, value)
- } else {
- return reflect.ValueOf(int(tmp)), nil
- }
- case reflect.Int8:
- tmp := toInteger(value).value
- if tmp < int64_minInt8 || tmp > int64_maxInt8 {
- return reflect.Value{}, fmt.Errorf("RangeError: %d (%v) to int8", tmp, value)
- } else {
- return reflect.ValueOf(int8(tmp)), nil
- }
- case reflect.Int16:
- tmp := toInteger(value).value
- if tmp < int64_minInt16 || tmp > int64_maxInt16 {
- return reflect.Value{}, fmt.Errorf("RangeError: %d (%v) to int16", tmp, value)
- } else {
- return reflect.ValueOf(int16(tmp)), nil
- }
- case reflect.Int32:
- tmp := toInteger(value).value
- if tmp < int64_minInt32 || tmp > int64_maxInt32 {
- return reflect.Value{}, fmt.Errorf("RangeError: %d (%v) to int32", tmp, value)
- } else {
- return reflect.ValueOf(int32(tmp)), nil
- }
- case reflect.Int64:
- // We convert to float64 here because converting to int64 will not tell us
- // if a value is outside the range of int64
- tmp := toIntegerFloat(value)
- if tmp < float_minInt64 || tmp > float_maxInt64 {
- return reflect.Value{}, fmt.Errorf("RangeError: %d (%v) to int", tmp, value)
- } else {
- return reflect.ValueOf(int64(tmp)), nil
- }
- case reflect.Uint:
- // We convert to float64 here because converting to int64 will not tell us
- // if a value is outside the range of uint
- tmp := toIntegerFloat(value)
- if tmp < 0 || tmp > float_maxUint {
- return reflect.Value{}, fmt.Errorf("RangeError: %d (%v) to uint", tmp, value)
- } else {
- return reflect.ValueOf(uint(tmp)), nil
- }
- case reflect.Uint8:
- tmp := toInteger(value).value
- if tmp < 0 || tmp > int64_maxUint8 {
- return reflect.Value{}, fmt.Errorf("RangeError: %d (%v) to uint8", tmp, value)
- } else {
- return reflect.ValueOf(uint8(tmp)), nil
- }
- case reflect.Uint16:
- tmp := toInteger(value).value
- if tmp < 0 || tmp > int64_maxUint16 {
- return reflect.Value{}, fmt.Errorf("RangeError: %d (%v) to uint16", tmp, value)
- } else {
- return reflect.ValueOf(uint16(tmp)), nil
- }
- case reflect.Uint32:
- tmp := toInteger(value).value
- if tmp < 0 || tmp > int64_maxUint32 {
- return reflect.Value{}, fmt.Errorf("RangeError: %d (%v) to uint32", tmp, value)
- } else {
- return reflect.ValueOf(uint32(tmp)), nil
- }
- case reflect.Uint64:
- // We convert to float64 here because converting to int64 will not tell us
- // if a value is outside the range of uint64
- tmp := toIntegerFloat(value)
- if tmp < 0 || tmp > float_maxUint64 {
- return reflect.Value{}, fmt.Errorf("RangeError: %f (%v) to uint64", tmp, value)
- } else {
- return reflect.ValueOf(uint64(tmp)), nil
- }
- case reflect.Float32:
- tmp := toFloat(value)
- tmp1 := tmp
- if 0 > tmp1 {
- tmp1 = -tmp1
- }
- if tmp1 < math.SmallestNonzeroFloat32 || tmp1 > math.MaxFloat32 {
- return reflect.Value{}, fmt.Errorf("RangeError: %f (%v) to float32", tmp, value)
- } else {
- return reflect.ValueOf(float32(tmp)), nil
- }
- case reflect.Float64:
- value := toFloat(value)
- return reflect.ValueOf(float64(value)), nil
- case reflect.String:
- return reflect.ValueOf(value.toString()), nil
- case reflect.Interface:
- return reflect.ValueOf(value.exportNative()), nil
- }
-
- dbgf("%/panic//%@: Invalid: (%v) to reflect.Kind: %v", value, kind)
- panic("")
-}
-
-func stringToReflectValue(value string, kind reflect.Kind) (reflect.Value, error) {
- switch kind {
- case reflect.Bool:
- value, err := strconv.ParseBool(value)
- if err != nil {
- return reflect.Value{}, err
- }
- return reflect.ValueOf(value), nil
- case reflect.Int:
- value, err := strconv.ParseInt(value, 0, 0)
- if err != nil {
- return reflect.Value{}, err
- }
- return reflect.ValueOf(int(value)), nil
- case reflect.Int8:
- value, err := strconv.ParseInt(value, 0, 8)
- if err != nil {
- return reflect.Value{}, err
- }
- return reflect.ValueOf(int8(value)), nil
- case reflect.Int16:
- value, err := strconv.ParseInt(value, 0, 16)
- if err != nil {
- return reflect.Value{}, err
- }
- return reflect.ValueOf(int16(value)), nil
- case reflect.Int32:
- value, err := strconv.ParseInt(value, 0, 32)
- if err != nil {
- return reflect.Value{}, err
- }
- return reflect.ValueOf(int32(value)), nil
- case reflect.Int64:
- value, err := strconv.ParseInt(value, 0, 64)
- if err != nil {
- return reflect.Value{}, err
- }
- return reflect.ValueOf(int64(value)), nil
- case reflect.Uint:
- value, err := strconv.ParseUint(value, 0, 0)
- if err != nil {
- return reflect.Value{}, err
- }
- return reflect.ValueOf(uint(value)), nil
- case reflect.Uint8:
- value, err := strconv.ParseUint(value, 0, 8)
- if err != nil {
- return reflect.Value{}, err
- }
- return reflect.ValueOf(uint8(value)), nil
- case reflect.Uint16:
- value, err := strconv.ParseUint(value, 0, 16)
- if err != nil {
- return reflect.Value{}, err
- }
- return reflect.ValueOf(uint16(value)), nil
- case reflect.Uint32:
- value, err := strconv.ParseUint(value, 0, 32)
- if err != nil {
- return reflect.Value{}, err
- }
- return reflect.ValueOf(uint32(value)), nil
- case reflect.Uint64:
- value, err := strconv.ParseUint(value, 0, 64)
- if err != nil {
- return reflect.Value{}, err
- }
- return reflect.ValueOf(uint64(value)), nil
- case reflect.Float32:
- value, err := strconv.ParseFloat(value, 32)
- if err != nil {
- return reflect.Value{}, err
- }
- return reflect.ValueOf(float32(value)), nil
- case reflect.Float64:
- value, err := strconv.ParseFloat(value, 64)
- if err != nil {
- return reflect.Value{}, err
- }
- return reflect.ValueOf(float64(value)), nil
- case reflect.String:
- return reflect.ValueOf(value), nil
- }
-
- dbgf("%/panic//%@: Invalid: \"%s\" to reflect.Kind: %v", value, kind)
- panic("")
-}