// scan the value by fields, and set to v func rawScanStruct(v reflect.Value, fields []string, scanner rowScaner) (err error) { if v.IsNil() { e := fmt.Sprintf("struct can not be nil, but got %#v", v.Interface()) return errors.New(e) } dest := make([]interface{}, len(fields)) for v.Kind() == reflect.Ptr { v = v.Elem() } // Loop over column names and find field in s to bind to // based on column name. all returned columns must match // a field in the s struct for x, fieldName := range fields { f := v.FieldByName(fieldName) if f == zeroVal { e := fmt.Sprintf("Scanner: No field %s in type %s", fieldName, v.Type()) return errors.New(e) } else { dest[x] = f.Addr().Interface() } } err = scanner.Scan(dest...) return }
// ConfigItemWhenValidation will validate that the when element of a config item is in a valid format and references other valid, created objects. func ConfigItemWhenValidation(v *validator.Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool { root, ok := topStruct.Interface().(*RootConfig) if !ok { // this is an issue with the code and really should be a panic return true } if fieldKind != reflect.String { // this is an issue with the code and really should be a panic return true } var whenValue string whenValue = field.String() if whenValue == "" { return true } splitString := "=" if strings.Contains(whenValue, "!=") { splitString = "!=" } parts := strings.SplitN(whenValue, splitString, 2) if len(parts) >= 2 { whenValue = parts[0] } return configItemExists(whenValue, root) }
func ContainerNameUnique(v *validator.Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool { if fieldKind != reflect.String { return true } containerName := field.String() if containerName == "" { return true } if hasReplTemplate(field) { // all bets are off return true } root, ok := topStruct.Interface().(*RootConfig) if !ok { // this is an issue with the code and really should be a panic return true } currentContainer := getCurrentContainer(currentStructOrField) if currentContainer == nil { // this is an issue with the code and really should be a panic return true } container := getContainerFromName(containerName, currentContainer, root) if container != nil { return false } return true }
func (d *commonDialect) SqlTag(value reflect.Value, size int) string { switch value.Kind() { case reflect.Bool: return "BOOLEAN" case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uintptr: return "INTEGER" case reflect.Int64, reflect.Uint64: return "BIGINT" case reflect.Float32, reflect.Float64: return "FLOAT" case reflect.String: if size > 0 && size < 65532 { return fmt.Sprintf("VARCHAR(%d)", size) } else { return "VARCHAR(65532)" } case reflect.Struct: if value.Type() == timeType { return "TIMESTAMP" } default: if _, ok := value.Interface().([]byte); ok { if size > 0 && size < 65532 { return fmt.Sprintf("BINARY(%d)", size) } else { return "BINARY(65532)" } } } panic(fmt.Sprintf("invalid sql type %s (%s) for commonDialect", value.Type().Name(), value.Kind().String())) }
func (par *parserParser) ParseValue(ctx *parseContext, valueOf reflect.Value, location int, err *Error) int { var v Parser if par.ptr { v = valueOf.Addr().Interface().(Parser) } else { if valueOf.Kind() == reflect.Ptr { valueOf = reflect.New(valueOf.Type().Elem()) } v = valueOf.Interface().(Parser) } l, e := v.ParseValue(ctx.str, location) if e != nil { switch ev := e.(type) { case Error: err.Location = ev.Location err.Message = ev.Message err.Str = ev.Str return -1 } err.Location = location err.Message = e.Error() return -1 } location = l if location > len(ctx.str) { panic("Invalid parser") } return location }
func (mssql) SqlTag(value reflect.Value, size int, autoIncrease bool) string { switch value.Kind() { case reflect.Bool: return "bit" case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uintptr: if autoIncrease { return "int IDENTITY(1,1)" } return "int" case reflect.Int64, reflect.Uint64: if autoIncrease { return "bigint IDENTITY(1,1)" } return "bigint" case reflect.Float32, reflect.Float64: return "float" case reflect.String: if size > 0 && size < 65532 { return fmt.Sprintf("nvarchar(%d)", size) } return "text" case reflect.Struct: if _, ok := value.Interface().(time.Time); ok { return "datetime2" } default: if _, ok := value.Interface().([]byte); ok { if size > 0 && size < 65532 { return fmt.Sprintf("varchar(%d)", size) } return "text" } } panic(fmt.Sprintf("invalid sql type %s (%s) for mssql", value.Type().Name(), value.Kind().String())) }
// IsZero returns true when the value is a zero for the type func isZero(data reflect.Value) bool { if !data.CanInterface() { return true } tpe := data.Type() return reflect.DeepEqual(data.Interface(), reflect.Zero(tpe).Interface()) }
func (d base) setModelValue(driverValue, fieldValue reflect.Value) error { switch fieldValue.Type().Kind() { case reflect.Bool: fieldValue.SetBool(d.dialect.parseBool(driverValue.Elem())) case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: fieldValue.SetInt(driverValue.Elem().Int()) case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: // reading uint from int value causes panic switch driverValue.Elem().Kind() { case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: fieldValue.SetUint(uint64(driverValue.Elem().Int())) default: fieldValue.SetUint(driverValue.Elem().Uint()) } case reflect.Float32, reflect.Float64: fieldValue.SetFloat(driverValue.Elem().Float()) case reflect.String: fieldValue.SetString(string(driverValue.Elem().Bytes())) case reflect.Slice: if reflect.TypeOf(driverValue.Interface()).Elem().Kind() == reflect.Uint8 { fieldValue.SetBytes(driverValue.Elem().Bytes()) } case reflect.Struct: switch fieldValue.Interface().(type) { case time.Time: fieldValue.Set(driverValue.Elem()) default: if scanner, ok := fieldValue.Addr().Interface().(sql.Scanner); ok { return scanner.Scan(driverValue.Interface()) } } } return nil }
func (t *SpecTest) haveError(fn interface{}) (bool, error) { t.doDebug(func() { t.Logf("Function %#v has an error", fn) }) var errval reflect.Value switch fn.(type) { case FnCall: fncall := fn.(FnCall) fntyp := fncall.fn.Type() if !reflect.TypeOf(errors.New("error")).AssignableTo(fntyp.Out(fntyp.NumOut() - 1)) { return false, errors.New("HaveError function call's last Value must be os.Error") } errval = fncall.out[len(fncall.out)-1] default: return false, errors.New("HaveError needs a function call Value") } var fnerr error switch v := errval.Interface(); v.(type) { case nil: fnerr = nil case error: fnerr = v.(error) default: return false, errors.New("Function call can not have error") } return fnerr != nil, nil }
func (d *decoder) parse_unmarshaler(v reflect.Value) bool { m, ok := v.Interface().(Unmarshaler) if !ok { // T doesn't work, try *T if v.Kind() != reflect.Ptr && v.CanAddr() { m, ok = v.Addr().Interface().(Unmarshaler) if ok { v = v.Addr() } } } if ok && (v.Kind() != reflect.Ptr || !v.IsNil()) { if d.read_one_value() { err := m.UnmarshalBencode(d.buf.Bytes()) d.buf.Reset() if err != nil { panic(&UnmarshalerError{v.Type(), err}) } return true } d.buf.Reset() } return false }
// callSliceRequired returns true if CallSlice is required instead of Call. func callSliceRequired(param reflect.Type, val reflect.Value) bool { vt := val.Type() for param.Kind() == reflect.Slice { if val.Kind() == reflect.Interface { val = reflect.ValueOf(val.Interface()) vt = val.Type() } if vt.Kind() != reflect.Slice { return false } vt = vt.Elem() if val.Kind() != reflect.Invalid { if val.Len() > 0 { val = val.Index(0) } else { val = reflect.Value{} } } param = param.Elem() } return true }
func (scope *Scope) getColumnsAsScope(column string) *Scope { values := scope.IndirectValue() switch values.Kind() { case reflect.Slice: modelType := values.Type().Elem() if modelType.Kind() == reflect.Ptr { modelType = modelType.Elem() } fieldStruct, _ := modelType.FieldByName(column) var columns reflect.Value if fieldStruct.Type.Kind() == reflect.Slice || fieldStruct.Type.Kind() == reflect.Ptr { columns = reflect.New(reflect.SliceOf(reflect.PtrTo(fieldStruct.Type.Elem()))).Elem() } else { columns = reflect.New(reflect.SliceOf(reflect.PtrTo(fieldStruct.Type))).Elem() } for i := 0; i < values.Len(); i++ { column := reflect.Indirect(values.Index(i)).FieldByName(column) if column.Kind() == reflect.Ptr { column = column.Elem() } if column.Kind() == reflect.Slice { for i := 0; i < column.Len(); i++ { columns = reflect.Append(columns, column.Index(i).Addr()) } } else { columns = reflect.Append(columns, column.Addr()) } } return scope.New(columns.Interface()) case reflect.Struct: return scope.New(values.FieldByName(column).Addr().Interface()) } return nil }
func (f encFnInfo) getValueForMarshalInterface(rv reflect.Value, indir int8) (v interface{}, proceed bool) { if indir == 0 { v = rv.Interface() } else if indir == -1 { // If a non-pointer was passed to Encode(), then that value is not addressable. // Take addr if addresable, else copy value to an addressable value. if rv.CanAddr() { v = rv.Addr().Interface() } else { rv2 := reflect.New(rv.Type()) rv2.Elem().Set(rv) v = rv2.Interface() // fmt.Printf("rv.Type: %v, rv2.Type: %v, v: %v\n", rv.Type(), rv2.Type(), v) } } else { for j := int8(0); j < indir; j++ { if rv.IsNil() { f.ee.EncodeNil() return } rv = rv.Elem() } v = rv.Interface() } return v, true }
func (f encFnInfo) ext(rv reflect.Value) { // if this is a struct|array and it was addressable, then pass the address directly (not the value) if k := rv.Kind(); (k == reflect.Struct || k == reflect.Array) && rv.CanAddr() { rv = rv.Addr() } f.ee.EncodeExt(rv.Interface(), f.xfTag, f.xfFn, f.e) }
func isZero(v reflect.Value) bool { switch v.Kind() { case reflect.Func, reflect.Map, reflect.Slice: return v.IsNil() case reflect.Array: z := true for i := 0; i < v.Len(); i++ { z = z && isZero(v.Index(i)) } return z case reflect.Struct: if v.Type() == reflect.TypeOf(t) { if v.Interface().(time.Time).IsZero() { return true } return false } z := true for i := 0; i < v.NumField(); i++ { z = z && isZero(v.Field(i)) } return z } // Compare other types directly: z := reflect.Zero(v.Type()) return v.Interface() == z.Interface() }
func encodeField(w io.Writer, f reflect.Value) error { if f.Type() == timeType { return encodeTime(w, f) } switch f.Kind() { case reflect.Uint8: fallthrough case reflect.Uint16: fallthrough case reflect.Uint32: fallthrough case reflect.Uint64: fallthrough case reflect.Int64: fallthrough case reflect.Int32: fallthrough case reflect.Int16: fallthrough case reflect.Int8: return binary.Write(w, byteOrder, f.Interface()) case reflect.String: return encodeStrField(w, f) case reflect.Slice: return encodeArray(w, f) case reflect.Interface: return encodeField(w, f.Elem()) default: panic(fmt.Sprintf("unimplemented kind %v", f)) } }
func convertType(v reflect.Value) (*string, error) { v = reflect.Indirect(v) if !v.IsValid() { return nil, nil } var str string switch value := v.Interface().(type) { case string: str = value case []byte: str = base64.StdEncoding.EncodeToString(value) case bool: str = strconv.FormatBool(value) case int64: str = strconv.FormatInt(value, 10) case float64: str = strconv.FormatFloat(value, 'f', -1, 64) case time.Time: str = value.UTC().Format(RFC822) default: err := fmt.Errorf("Unsupported value for param %v (%s)", v.Interface(), v.Type()) return nil, err } return &str, nil }
func parseFlagField(field reflect.StructField, fieldVal reflect.Value) *Option { checkTags(field, flagTag) checkExported(field, flagTag) names := parseCommaNames(field.Tag.Get(flagTag)) if len(names) == 0 { panicCommand("at least one flag name must be specified (field %s)", field.Name) } opt := &Option{ Names: names, Flag: true, Description: field.Tag.Get(descriptionTag), } if field.Type.Implements(decoderT) { opt.Decoder = fieldVal.Interface().(OptionDecoder) } else if fieldVal.CanAddr() && reflect.PtrTo(field.Type).Implements(decoderT) { opt.Decoder = fieldVal.Addr().Interface().(OptionDecoder) } else { switch field.Type.Kind() { case reflect.Bool: opt.Decoder = NewFlagDecoder(fieldVal.Addr().Interface().(*bool)) case reflect.Int: opt.Decoder = NewFlagAccumulator(fieldVal.Addr().Interface().(*int)) opt.Plural = true default: panicCommand("field type not valid as a flag -- did you mean to use %q instead? (field %s)", "option", field.Name) } } opt.validate() return opt }
func defaultReturnHandler() ReturnHandler { return func(ctx *Context, vals []reflect.Value) { rv := ctx.GetVal(inject.InterfaceOf((*http.ResponseWriter)(nil))) resp := rv.Interface().(http.ResponseWriter) var respVal reflect.Value if len(vals) > 1 && vals[0].Kind() == reflect.Int { resp.WriteHeader(int(vals[0].Int())) respVal = vals[1] } else if len(vals) > 0 { respVal = vals[0] if isError(respVal) { err := respVal.Interface().(error) if err != nil { ctx.internalServerError(ctx, err) } return } else if canDeref(respVal) { if respVal.IsNil() { return // Ignore nil error } } } if canDeref(respVal) { respVal = respVal.Elem() } if isByteSlice(respVal) { resp.Write(respVal.Bytes()) } else { resp.Write([]byte(respVal.String())) } } }
func isZero(v reflect.Value) bool { switch v.Kind() { case reflect.String: return len(v.String()) == 0 case reflect.Ptr, reflect.Interface: return v.IsNil() case reflect.Slice: return v.Len() == 0 case reflect.Map: return v.Len() == 0 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: return v.Int() == 0 case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: return v.Uint() == 0 case reflect.Float32, reflect.Float64: return v.Float() == 0 case reflect.Bool: return !v.Bool() case reflect.Struct: vt := v.Type() if vt == typeTime { return v.Interface().(time.Time).IsZero() } for i := 0; i < v.NumField(); i++ { if vt.Field(i).PkgPath != "" { continue // Private field } if !isZero(v.Field(i)) { return false } } return true } return false }
// convert a value back to the original error interface. panics if value is not // nil and also does not implement error. func value2error(v reflect.Value) error { i := v.Interface() if i == nil { return nil } return i.(error) }
func (e *encoder) addSlice(v reflect.Value) { vi := v.Interface() if d, ok := vi.(D); ok { for _, elem := range d { e.addElem(elem.Name, reflect.ValueOf(elem.Value), false) } return } if d, ok := vi.(RawD); ok { for _, elem := range d { e.addElem(elem.Name, reflect.ValueOf(elem.Value), false) } return } l := v.Len() et := v.Type().Elem() if et == typeDocElem { for i := 0; i < l; i++ { elem := v.Index(i).Interface().(DocElem) e.addElem(elem.Name, reflect.ValueOf(elem.Value), false) } return } if et == typeRawDocElem { for i := 0; i < l; i++ { elem := v.Index(i).Interface().(RawDocElem) e.addElem(elem.Name, reflect.ValueOf(elem.Value), false) } return } for i := 0; i < l; i++ { e.addElem(itoa(i), v.Index(i), false) } }
// printValue is like printArg but starts with a reflect value, not an interface{} value. func (p *pp) printValue(value reflect.Value, verb rune, plus, goSyntax bool, depth int) (wasString bool) { if !value.IsValid() { if verb == 'T' || verb == 'v' { p.buf.Write(nilAngleBytes) } else { p.badVerb(verb) } return false } // Special processing considerations. // %T (the value's type) and %p (its address) are special; we always do them first. switch verb { case 'T': p.printArg(value.Type().String(), 's', false, false, 0) return false case 'p': p.fmtPointer(value, verb, goSyntax) return false } // Handle values with special methods. // Call always, even when arg == nil, because handleMethods clears p.fmt.plus for us. p.arg = nil // Make sure it's cleared, for safety. if value.CanInterface() { p.arg = value.Interface() } if isString, handled := p.handleMethods(verb, plus, goSyntax, depth); handled { return isString } return p.printReflectValue(value, verb, plus, goSyntax, depth) }
// writeExtensions writes all the extensions in pv. // pv is assumed to be a pointer to a protocol message struct that is extendable. func writeExtensions(w *textWriter, pv reflect.Value) error { emap := extensionMaps[pv.Type().Elem()] ep := pv.Interface().(extendableProto) // Order the extensions by ID. // This isn't strictly necessary, but it will give us // canonical output, which will also make testing easier. var m map[int32]Extension if em, ok := ep.(extensionsMap); ok { m = em.ExtensionMap() } else if em, ok := ep.(extensionsBytes); ok { eb := em.GetExtensions() var err error m, err = BytesToExtensionsMap(*eb) if err != nil { return err } } ids := make([]int32, 0, len(m)) for id := range m { ids = append(ids, id) } sort.Sort(int32Slice(ids)) for _, extNum := range ids { ext := m[extNum] var desc *ExtensionDesc if emap != nil { desc = emap[extNum] } if desc == nil { // Unknown extension. if err := writeUnknownStruct(w, ext.enc); err != nil { return err } continue } pb, err := GetExtension(ep, desc) if err != nil { return fmt.Errorf("failed getting extension: %v", err) } // Repeated extensions will appear as a slice. if !desc.repeated() { if err := writeExtension(w, desc.Name, pb); err != nil { return err } } else { v := reflect.ValueOf(pb) for i := 0; i < v.Len(); i++ { if err := writeExtension(w, desc.Name, v.Index(i).Interface()); err != nil { return err } } } } return nil }
// for insert and update // If already assigned, then just ignore tag func GetValQuoteStr(val reflect.Value) (string, error) { switch val.Kind() { case reflect.Bool: boolStr := "N" if val.Bool() { boolStr = "Y" } return boolStr, nil case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: return strconv.FormatInt(val.Int(), 10), nil case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: return strconv.FormatUint(val.Uint(), 10), nil case reflect.Float32, reflect.Float64: return strconv.FormatFloat(val.Float(), 'f', -1, 64), nil case reflect.String: return QuoteStr(val.String()), nil case reflect.Slice: //[]byte if val.Type().Elem().Name() != "uint8" { return "", fmt.Errorf("GetValQuoteStr> slicetype is not []byte: %v", val.Interface()) } return QuoteStr(string(val.Interface().([]byte))), nil default: return "", fmt.Errorf("GetValQuoteStr> reflect.Value is not a string/int/uint/float/bool/[]byte!\nval: %v", val) } return "", nil }
func (q *queryParser) parseScalar(v url.Values, r reflect.Value, name string, tag reflect.StructTag) error { switch value := r.Interface().(type) { case string: v.Set(name, value) case []byte: if !r.IsNil() { v.Set(name, base64.StdEncoding.EncodeToString(value)) } case bool: v.Set(name, strconv.FormatBool(value)) case int64: v.Set(name, strconv.FormatInt(value, 10)) case int: v.Set(name, strconv.Itoa(value)) case float64: v.Set(name, strconv.FormatFloat(value, 'f', -1, 64)) case float32: v.Set(name, strconv.FormatFloat(float64(value), 'f', -1, 32)) case time.Time: const ISO8601UTC = "2006-01-02T15:04:05Z" v.Set(name, value.UTC().Format(ISO8601UTC)) default: return fmt.Errorf("unsupported value for param %s: %v (%s)", name, r.Interface(), r.Type().Name()) } return nil }
// ComponentExistsValidation will validate that the specified component name is present in the current YAML. func ComponentExistsValidation(v *validator.Validate, topStruct reflect.Value, currentStructOrField reflect.Value, field reflect.Value, fieldType reflect.Type, fieldKind reflect.Kind, param string) bool { // validates that the component exists in the root.Components slice root, ok := topStruct.Interface().(*RootConfig) if !ok { // this is an issue with the code and really should be a panic return true } if fieldKind != reflect.String { // this is an issue with the code and really should be a panic return true } var componentName string componentName = field.String() parts := strings.SplitN(componentName, ",", 2) if len(parts) >= 2 { componentName = parts[0] } return componentExists(componentName, root) }
func (q *Query) findPopulatePath(path string) { parts := strings.Split(path, ".") resultVal := reflect.ValueOf(q.parentStruct).Elem() var refVal reflect.Value partsLen := len(parts) for i := 0; i < partsLen; i++ { elem := parts[i] if i == 0 { refVal = resultVal.FieldByName(elem) structTag, _ := resultVal.Type().FieldByName(elem) q.popSchema = structTag.Tag.Get(q.z.modelTag) } else if i == partsLen-1 { structTag, _ := refVal.Type().FieldByName(elem) q.popSchema = structTag.Tag.Get(q.z.modelTag) refVal = refVal.FieldByName(elem) } else { //refVal = handleSlice(refVal, elem, path) refVal = refVal.FieldByName(elem) } if !refVal.IsValid() { panic("field `" + elem + "` not found in populate path `" + path + "`") } } if refVal.Kind() == reflect.Slice { q.isSlice = true } q.populateField = refVal.Interface() }
func (w *unknownCheckWalker) Primitive(v reflect.Value) error { if v.Interface() == unknownValue() { w.Unknown = true } return nil }
func decStringSlice(state *decoderState, v reflect.Value, length int, ovfl error) bool { slice, ok := v.Interface().([]string) if !ok { // It is kind string but not type string. TODO: We can handle this unsafely. return false } for i := 0; i < length; i++ { if state.b.Len() == 0 { errorf("decoding string array or slice: length exceeds input size (%d elements)", length) } u := state.decodeUint() n := int(u) if n < 0 || uint64(n) != u || n > state.b.Len() { errorf("length of string exceeds input size (%d bytes)", u) } if n > state.b.Len() { errorf("string data too long for buffer: %d", n) } // Read the data. data := make([]byte, n) if _, err := state.b.Read(data); err != nil { errorf("error decoding string: %s", err) } slice[i] = string(data) } return true }