func parseFloat(value string) (reflect.Value, error) { b, err := strconv.ParseFloat(value, 64) if err != nil { return reflect.ValueOf(nil), conversionError(value, "float64") } return reflect.ValueOf(b), nil }
// ObjectsAreEqual determines if two objects are considered equal. // // This function does no assertion of any kind. func ObjectsAreEqual(expected, actual interface{}) bool { if expected == nil || actual == nil { return expected == actual } if reflect.DeepEqual(expected, actual) { return true } expectedValue := reflect.ValueOf(expected) actualValue := reflect.ValueOf(actual) if expectedValue == actualValue { return true } // Attempt comparison after type conversion if actualValue.Type().ConvertibleTo(expectedValue.Type()) && expectedValue == actualValue.Convert(expectedValue.Type()) { return true } // Last ditch effort if fmt.Sprintf("%#v", expected) == fmt.Sprintf("%#v", actual) { return true } return false }
func (t *Table) CopyDataLine(dims cube.Dimensions, aggs cube.Aggregates) string { ints := make([]interface{}, 0, len(t.aggcols)+len(t.dimcols)) vDims := reflect.ValueOf(dims) vAggs := reflect.ValueOf(aggs) i := 0 visitor := func(fieldValue reflect.Value, fieldDescription reflect.StructField) { ints = append(ints, t.dimcols[i].PrintInterface(fieldValue.Interface())) i += 1 } VisitDimensions(vDims, visitor) j := 0 visitorAgg := func(fieldValue reflect.Value, fieldDescription reflect.StructField) { ints = append(ints, t.aggcols[j].PrintInterface(fieldValue.Elem().Interface())) j += 1 } VisitAggregates(vAggs, visitorAgg) /* for _, col := range t.dimcols { ints = append(ints, col.PrintInterface(vDims.Field(col.Index()).Interface())) } for _, col := range t.aggcols { ints = append(ints, col.PrintInterface(vAggs.Field(col.Index()).Elem().Interface())) }*/ fs := t.getCopyDataLineFormatString() return fmt.Sprintf(fs, ints...) }
func Mod(a, b interface{}) (int64, error) { av := reflect.ValueOf(a) bv := reflect.ValueOf(b) var ai, bi int64 switch av.Kind() { case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: ai = av.Int() default: return 0, errors.New("Modulo operator can't be used with non integer value") } switch bv.Kind() { case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: bi = bv.Int() default: return 0, errors.New("Modulo operator can't be used with non integer value") } if bi == 0 { return 0, errors.New("The number can't be divided by zero at modulo operation") } return ai % bi, nil }
// Exec executes the statement represented by the InsertBuilder // It returns the raw database/sql Result and an error if there was one. // Regarding LastInsertID(): If you insert multiple rows using a single // INSERT statement, LAST_INSERT_ID() returns the value generated for // the first inserted row only. The reason for this is to make it possible to // reproduce easily the same INSERT statement against some other server. func (b *InsertBuilder) Exec() (sql.Result, error) { sql, args := b.ToSql() fullSql, err := Preprocess(sql, args) if err != nil { return nil, b.EventErrKv("dbr.insert.exec.interpolate", err, kvs{"sql": sql, "args": fmt.Sprint(args)}) } // Start the timer: startTime := time.Now() defer func() { b.TimingKv("dbr.insert", time.Since(startTime).Nanoseconds(), kvs{"sql": fullSql}) }() result, err := b.runner.Exec(fullSql) if err != nil { return result, b.EventErrKv("dbr.insert.exec.exec", err, kvs{"sql": fullSql}) } // If the structure has an "Id" field which is an int64, set it from the LastInsertId(). Otherwise, don't bother. if len(b.Recs) == 1 { rec := b.Recs[0] val := reflect.Indirect(reflect.ValueOf(rec)) if val.Kind() == reflect.Struct && val.CanSet() { // @todo important: make Id configurable to match all magento internal ID columns if idField := val.FieldByName("Id"); idField.IsValid() && idField.Kind() == reflect.Int64 { if lastID, err := result.LastInsertId(); err == nil { idField.Set(reflect.ValueOf(lastID)) } else { b.EventErrKv("dbr.insert.exec.last_inserted_id", err, kvs{"sql": fullSql}) } } } } return result, nil }
// Union outputs a collection that holds unique values of in and values collections func Union(in Collection, values Collection, out Pointer) error { if !IsCollection(in) { return NotACollection("Value %v is not a collection", in) } if !IsCollection(values) { return NotACollection("Value %v is not a collection", values) } if !IsPointer(out) { return NotPointer("Value %v is not a pointer", out) } inVal := reflect.ValueOf(in) valuesVal := reflect.ValueOf(values) outVal := reflect.ValueOf(out) if a, b := inVal.Type(), valuesVal.Type(); a != b { return NotAssignable("Collection of type '%v' doesn't match type ", a, b) } if a, c := inVal.Type(), outVal.Elem().Type(); !a.AssignableTo(c) { return NotAssignable("Collection of type '%v' is not assignable to output of type '%v'", a, c) } for i := 0; i < valuesVal.Len(); i++ { inVal = reflect.Append(inVal, valuesVal.Index(i)) } if err := Unique(inVal.Interface(), out); err != nil { return err } return nil }
func ReturnWhenSet(a, k interface{}) interface{} { av, isNil := indirect(reflect.ValueOf(a)) if isNil { return "" } var avv reflect.Value switch av.Kind() { case reflect.Array, reflect.Slice: index, ok := k.(int) if ok && av.Len() > index { avv = av.Index(index) } case reflect.Map: kv := reflect.ValueOf(k) if kv.Type().AssignableTo(av.Type().Key()) { avv = av.MapIndex(kv) } } if avv.IsValid() { switch avv.Kind() { case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: return avv.Int() case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: return avv.Uint() case reflect.Float32, reflect.Float64: return avv.Float() case reflect.String: return avv.String() } } return "" }
func (mw *middlewareHandler) invoke(ctx reflect.Value, rw ResponseWriter, req *Request, next NextMiddlewareFunc) { if mw.Generic { mw.GenericMiddleware(rw, req, next) } else { mw.DynamicMiddleware.Call([]reflect.Value{ctx, reflect.ValueOf(rw), reflect.ValueOf(req), reflect.ValueOf(next)}) } }
// Beat the supplied handler into a uniform signature. panics if incompatible // (may only happen when the wrapped fun is called) func fixHandlerSignature(f interface{}) parametrizedHandler { // classic net/http.Hander implementors can easily be converted if httph, ok := f.(http.Handler); ok { return func(ctx *Context, args ...string) error { httph.ServeHTTP(ctx.Response, ctx.Request) return nil } } fv := reflect.ValueOf(f) var callf valuefun = callableValue(fv) if !requiresContext(fv.Type()) { callf = disregardFirstArg(callf) } // now callf definitely accepts a *Context as its first arg if !lastRetIsError(fv) { callf = addNilErrorReturn(callf) } // now callf definitely returns an error as its last value if firstRetIsNonError(fv) { callf = writeFirstRetToFirstArg(callf) } // now callf definitely does not return its data: just an error // wrap callf in a function with pretty signature return func(ctx *Context, args ...string) error { argvs := make([]reflect.Value, len(args)+1) argvs[0] = reflect.ValueOf(ctx) for i, arg := range args { argvs[i+1] = reflect.ValueOf(arg) } rets := callf(argvs) return value2error(rets[0]) } }
func TestReflection(t *testing.T) { o := js.Global.Call("eval", "({ answer: 42 })") if reflect.ValueOf(o).Interface().(*js.Object) != o { t.Fail() } type S struct { Field *js.Object } s := S{o} v := reflect.ValueOf(&s).Elem() if v.Field(0).Interface().(*js.Object).Get("answer").Int() != 42 { t.Fail() } if v.Field(0).MethodByName("Get").Call([]reflect.Value{reflect.ValueOf("answer")})[0].Interface().(*js.Object).Int() != 42 { t.Fail() } v.Field(0).Set(reflect.ValueOf(js.Global.Call("eval", "({ answer: 100 })"))) if s.Field.Get("answer").Int() != 100 { t.Fail() } if fmt.Sprintf("%+v", s) != "{Field:[object Object]}" { t.Fail() } }
func (context *Context) valueOf(valuer func(interface{}, *qor.Context) interface{}, value interface{}, meta *Meta) interface{} { if valuer != nil { reflectValue := reflect.ValueOf(value) if reflectValue.Kind() != reflect.Ptr { reflectPtr := reflect.New(reflectValue.Type()) reflectPtr.Elem().Set(reflectValue) value = reflectPtr.Interface() } result := valuer(value, context.Context) if reflectValue := reflect.ValueOf(result); reflectValue.IsValid() { if reflectValue.Kind() == reflect.Ptr { if reflectValue.IsNil() || !reflectValue.Elem().IsValid() { return nil } result = reflectValue.Elem().Interface() } if meta.Type == "number" || meta.Type == "float" { if context.isNewRecord(value) && equal(reflect.Zero(reflect.TypeOf(result)).Interface(), result) { return nil } } return result } else { return nil } } utils.ExitWithMsg(fmt.Sprintf("No valuer found for meta %v of resource %v", meta.Name, meta.baseResource.Name)) return nil }
// lt evaluates the comparison a < b. func lt(arg1, arg2 interface{}) (bool, error) { v1 := reflect.ValueOf(arg1) k1, err := basicKind(v1) if err != nil { return false, err } v2 := reflect.ValueOf(arg2) k2, err := basicKind(v2) if err != nil { return false, err } if k1 != k2 { return false, errBadComparison } truth := false switch k1 { case boolKind, complexKind: return false, errBadComparisonType case floatKind: truth = v1.Float() < v2.Float() case intKind: truth = v1.Int() < v2.Int() case stringKind: truth = v1.String() < v2.String() case uintKind: truth = v1.Uint() < v2.Uint() default: panic("invalid kind") } return truth, nil }
func RPC2XML(value interface{}) (string, error) { out := "<value>" switch reflect.ValueOf(value).Kind() { case reflect.Int: out += fmt.Sprintf("<int>%d</int>", value.(int)) case reflect.Float64: out += fmt.Sprintf("<double>%f</double>", value.(float64)) case reflect.String: out += String2XML(value.(string)) case reflect.Bool: out += Bool2XML(value.(bool)) case reflect.Struct: if reflect.TypeOf(value).String() != "time.Time" { out += Struct2XML(value) } else { out += Time2XML(value.(time.Time)) } case reflect.Slice, reflect.Array: // FIXME: is it the best way to recognize '[]byte'? if reflect.TypeOf(value).String() != "[]uint8" { out += Array2XML(value) } else { out += Base642XML(value.([]byte)) } case reflect.Ptr: if reflect.ValueOf(value).IsNil() { out += "<nil/>" } } out += "</value>" return out, nil }
// NewVarWithFunc returns a new Var. get returns the value for the given key func NewVarWithFunc(field reflect.StructField, get func(string) string) (*Var, error) { newVar := &Var{} newVar.Parse(field) value, err := convert(newVar.Type, get(newVar.Key), newVar.Decode) if err != nil { return newVar, err } newVar.SetValue(value) if value == reflect.ValueOf(nil) { if newVar.Required { return newVar, fmt.Errorf("%s required", newVar.Key) } // Check if we have a default value to set, otherwise set the type's zero value if newVar.Default != reflect.ValueOf(nil) { newVar.SetValue(newVar.Default) } else { newVar.SetValue(reflect.Zero(newVar.Type)) } } if len(newVar.Options) > 0 { if !newVar.optionsContains(newVar.Value) { return newVar, fmt.Errorf(`%v="%v" not in allowed options: %v`, newVar.Key, newVar.Value, newVar.Options) } } return newVar, nil }
func main() { var x float64 = 6.54 v := reflect.ValueOf(x) fmt.Println("type:", reflect.TypeOf(x)) fmt.Println("value:", reflect.ValueOf(x)) fmt.Println("kind is float64:", v.Kind() == reflect.String) }
func handlerName(h HandlerFunc) string { t := reflect.ValueOf(h).Type() if t.Kind() == reflect.Func { return runtime.FuncForPC(reflect.ValueOf(h).Pointer()).Name() } return t.String() }
// Unique filters remove duplicate values from an array func Unique(in Collection, out Pointer) error { if !IsCollection(in) { return NotACollection("Value '%v' is not a collection", in) } if !IsPointer(out) { return NotPointer("Value '%v' is not a pointer", out) } inValue := reflect.ValueOf(in) inType := inValue.Type() outValue := reflect.ValueOf(out) outType := outValue.Type() if !inType.AssignableTo(outType.Elem()) { return NotAssignable("Value in of type '%v' can't be assigned to out of type '%v' ", inType, outType.Elem()) } newCollection := reflect.MakeSlice(inType, 0, 0) inLen := inValue.Len() for i := 0; i < inLen; i++ { if index, err := IndexOf(newCollection.Interface(), inValue.Index(i).Interface(), 0); err != nil { return err } else if index == -1 { newCollection = reflect.Append(newCollection, inValue.Index(i)) } } outValue.Elem().Set(newCollection) return nil }
// Магия, через reflect и таги "logfield"/"logresize" выставить все поля структуры LogData в // соответствующие значения из json-лога func parseJSONLines(lines [][]byte, res interface{}) { resType := reflect.TypeOf(res).Elem() resValue := reflect.ValueOf(res).Elem() for i := 0; i < resType.NumField(); i++ { field := resValue.Field(i) fieldType := resType.Field(i) fieldTag := fieldType.Tag if fieldTag.Get("logfield") != "" || fieldTag.Get("logresize") != "" { field.Set(reflect.MakeSlice(fieldType.Type, len(lines), len(lines))) } } resValue.FieldByName("Size").Set(reflect.ValueOf(len(lines))) for lineno, l := range lines { var ll map[string]string err := json.Unmarshal(l, &ll) if err == nil { for i := 0; i < resType.NumField(); i++ { field := resValue.Field(i) fieldTag := resType.Field(i).Tag.Get("logfield") if fieldTag != "" { valueFromJSON := reflect.ValueOf(ll[fieldTag]) field.Index(lineno).Set(valueFromJSON) } } } else { fmt.Printf("err: %v; %s\n", err, l) } } }
// WaitForNetworkConnectivity uses a NetworkConnectivityChecker to // periodically check for network connectivity. It returns true if // no NetworkConnectivityChecker is provided (waiting is disabled) // or when NetworkConnectivityChecker.HasNetworkConnectivity() // indicates connectivity. It waits and polls the checker once a second. // If any stop is broadcast, false is returned immediately. func WaitForNetworkConnectivity( connectivityChecker NetworkConnectivityChecker, stopBroadcasts ...<-chan struct{}) bool { if connectivityChecker == nil || 1 == connectivityChecker.HasNetworkConnectivity() { return true } NoticeInfo("waiting for network connectivity") ticker := time.NewTicker(1 * time.Second) for { if 1 == connectivityChecker.HasNetworkConnectivity() { return true } selectCases := make([]reflect.SelectCase, 1+len(stopBroadcasts)) selectCases[0] = reflect.SelectCase{ Dir: reflect.SelectRecv, Chan: reflect.ValueOf(ticker.C)} for i, stopBroadcast := range stopBroadcasts { selectCases[i+1] = reflect.SelectCase{ Dir: reflect.SelectRecv, Chan: reflect.ValueOf(stopBroadcast)} } chosen, _, ok := reflect.Select(selectCases) if chosen == 0 && ok { // Ticker case, so check again } else { // Stop case return false } } }
func (s *S) TestUnmarshal(c *C) { for i, item := range unmarshalTests { t := reflect.ValueOf(item.value).Type() var value interface{} switch t.Kind() { case reflect.Map: value = reflect.MakeMap(t).Interface() case reflect.String: t := reflect.ValueOf(item.value).Type() v := reflect.New(t) value = v.Interface() default: pt := reflect.ValueOf(item.value).Type() pv := reflect.New(pt.Elem()) value = pv.Interface() } err := goyaml.Unmarshal([]byte(item.data), value) c.Assert(err, IsNil, Commentf("Item #%d", i)) if t.Kind() == reflect.String { c.Assert(*value.(*string), Equals, item.value, Commentf("Item #%d", i)) } else { c.Assert(value, DeepEquals, item.value, Commentf("Item #%d", i)) } } }
func refPage(page interface{}, ref, methodName string) template.HTML { value := reflect.ValueOf(page) method := value.MethodByName(methodName) if method.IsValid() && method.Type().NumIn() == 1 && method.Type().NumOut() == 2 { result := method.Call([]reflect.Value{reflect.ValueOf(ref)}) url, err := result[0], result[1] if !err.IsNil() { jww.ERROR.Printf("%s", err.Interface()) return template.HTML(fmt.Sprintf("%s", err.Interface())) } if url.String() == "" { jww.ERROR.Printf("ref %s could not be found\n", ref) return template.HTML(ref) } return template.HTML(url.String()) } jww.ERROR.Printf("Can only create references from Page and Node objects.") return template.HTML(ref) }
func setValue(dstVal reflect.Value, src interface{}) { if dstVal.Kind() == reflect.Ptr { dstVal = reflect.Indirect(dstVal) } srcVal := reflect.ValueOf(src) if !srcVal.IsValid() { // src is literal nil if dstVal.CanAddr() { // Convert to pointer so that pointer's value can be nil'ed // dstVal = dstVal.Addr() } dstVal.Set(reflect.Zero(dstVal.Type())) } else if srcVal.Kind() == reflect.Ptr { if srcVal.IsNil() { srcVal = reflect.Zero(dstVal.Type()) } else { srcVal = reflect.ValueOf(src).Elem() } dstVal.Set(srcVal) } else { dstVal.Set(srcVal) } }
// After is exposed to templates, to iterate over all the items after N in a // rangeable list. It's meant to accompany First func After(index interface{}, seq interface{}) (interface{}, error) { if index == nil || seq == nil { return nil, errors.New("both limit and seq must be provided") } indexv, err := cast.ToIntE(index) if err != nil { return nil, err } if indexv < 1 { return nil, errors.New("can't return negative/empty count of items from sequence") } seqv := reflect.ValueOf(seq) seqv, isNil := indirect(seqv) if isNil { return nil, errors.New("can't iterate over a nil value") } switch seqv.Kind() { case reflect.Array, reflect.Slice, reflect.String: // okay default: return nil, errors.New("can't iterate over " + reflect.ValueOf(seq).Type().String()) } if indexv >= seqv.Len() { return nil, errors.New("no items left") } return seqv.Slice(indexv, seqv.Len()).Interface(), nil }
// Performs a request/response call for when the message is not NoWait and is // specified as Synchronous. func (me *Channel) call(req message, res ...message) error { if err := me.send(me, req); err != nil { return err } if req.wait() { select { case e := <-me.errors: return e case msg := <-me.rpc: if msg != nil { for _, try := range res { if reflect.TypeOf(msg) == reflect.TypeOf(try) { // *res = *msg vres := reflect.ValueOf(try).Elem() vmsg := reflect.ValueOf(msg).Elem() vres.Set(vmsg) return nil } } return ErrCommandInvalid } else { // RPC channel has been closed without an error, likely due to a hard // error on the Connection. This indicates we have already been // shutdown and if were waiting, will have returned from the errors chan. return ErrClosed } } } return nil }
func (t *typeValidator) Validate(data interface{}) *Result { result := new(Result) result.Inc() if data == nil || reflect.DeepEqual(reflect.Zero(reflect.TypeOf(data)), reflect.ValueOf(data)) { if len(t.Type) > 0 && !t.Type.Contains("null") { // TODO: if a property is not required it also passes this return sErr(errors.InvalidType(t.Path, t.In, strings.Join(t.Type, ","), "null")) } return result } // check if the type matches, should be used in every validator chain as first item val := reflect.Indirect(reflect.ValueOf(data)) schType, format := t.schemaInfoForType(data) isLowerInt := t.Format == "int64" && format == "int32" isLowerFloat := t.Format == "float64" && format == "float32" if val.Kind() != reflect.String && t.Format != "" && !(format == t.Format || isLowerInt || isLowerFloat) { return sErr(errors.InvalidType(t.Path, t.In, t.Format, format)) } if t.Format != "" && val.Kind() == reflect.String { return result } isFloatInt := schType == "number" && swag.IsFloat64AJSONInteger(val.Float()) && t.Type.Contains("integer") isIntFloat := schType == "integer" && t.Type.Contains("number") if !(t.Type.Contains(schType) || isFloatInt || isIntFloat) { return sErr(errors.InvalidType(t.Path, t.In, strings.Join(t.Type, ","), schType)) } return result }
func (me *Connection) call(req message, res ...message) error { // Special case for when the protocol header frame is sent insted of a // request method if req != nil { if err := me.send(&methodFrame{ChannelId: 0, Method: req}); err != nil { return err } } select { case err := <-me.errors: if err == nil { return ErrClosed } return err case msg := <-me.rpc: // Try to match one of the result types for _, try := range res { if reflect.TypeOf(msg) == reflect.TypeOf(try) { // *res = *msg vres := reflect.ValueOf(try).Elem() vmsg := reflect.ValueOf(msg).Elem() vres.Set(vmsg) return nil } } return ErrCommandInvalid } panic("unreachable") }
func (rw *ResponderWorker) Call(serviceMethod string, args interface{}, reply interface{}) error { methodName := strings.TrimLeft(serviceMethod, "Responder.") switch args.(type) { case CallDescriptor: cd := args.(CallDescriptor) switch reply.(type) { case *CallCost: rep := reply.(*CallCost) method := reflect.ValueOf(&cd).MethodByName(methodName) ret := method.Call([]reflect.Value{}) *rep = *(ret[0].Interface().(*CallCost)) case *float64: rep := reply.(*float64) method := reflect.ValueOf(&cd).MethodByName(methodName) ret := method.Call([]reflect.Value{}) *rep = *(ret[0].Interface().(*float64)) } case string: switch methodName { case "Status": *(reply.(*string)) = "Local!" case "Shutdown": *(reply.(*string)) = "Done!" } } return nil }
func BenchmarkHandlerCall(b *testing.B) { fn := func(params *jsonrpc2.EmptyParams) (interface{}, error) { return nil, nil } handler := handler{ method: reflect.ValueOf(fn), params: reflect.New(reflect.ValueOf(fn).Type().In(0).Elem()).Interface().(jsonrpc2.Params), } data, _ := json.Marshal(&jsonrpc2.EmptyParams{}) params, err := handler.DecodeParams(data) if err != nil { b.Fatal(err.Error()) } b.ResetTimer() b.ReportAllocs() for i := 0; i < b.N; i++ { handler.Call(params) } }
func TestNormalizationFuncGlobalExistence(t *testing.T) { // This test can be safely deleted when we will not support multiple flag formats root := NewKubectlCommand(cmdutil.NewFactory(nil), os.Stdin, os.Stdout, os.Stderr) if root.Parent() != nil { t.Fatal("We expect the root command to be returned") } if root.GlobalNormalizationFunc() == nil { t.Fatal("We expect that root command has a global normalization function") } if reflect.ValueOf(root.GlobalNormalizationFunc()).Pointer() != reflect.ValueOf(root.Flags().GetNormalizeFunc()).Pointer() { t.Fatal("root command seems to have a wrong normalization function") } sub := root for sub.HasSubCommands() { sub = sub.Commands()[0] } // In case of failure of this test check this PR: spf13/cobra#110 if reflect.ValueOf(sub.Flags().GetNormalizeFunc()).Pointer() != reflect.ValueOf(root.Flags().GetNormalizeFunc()).Pointer() { t.Fatal("child and root commands should have the same normalization functions") } }
// Convert a string into the specified type. // Return the type's zero value if we receive an empty string // Use the decode strategy defined func convert(t reflect.Type, value string, decode string) (reflect.Value, error) { if value == "" { return reflect.ValueOf(nil), nil } switch decode { // if no decode defined, try with type and then kind // if any type is defined then it will be used else fallback to kind case "": val, err := convertWithType(t, value) if err != nil { val, err = convertWithKind(t, value) } return val, err case "kind": return convertWithKind(t, value) case "type": return convertWithType(t, value) case "yaml": return convertWithYaml(t, value) default: return reflect.ValueOf(nil), conversionError(decode, `unsupported decode`) } }