Пример #1
0
func TestAtoi32(t *testing.T) { // must use bloody camel case to be recognised by go testing
	var (
		iv interface{} // use interface to ensure var type returned is int32
		v  int32
	)

	iv = clike.Atoi32("1256")

	switch iv.(type) {
	case int32:
		break

	default:
		t.Errorf("atoi32() did not return int32, no other ato32() tests executed")
		return
	}

	if iv.(int32) != 1256 {
		t.Fail()
	}

	v = clike.Atoi32("0x8000")
	if v != 0x8000 {
		t.Fail()
	}
}
Пример #2
0
/*
	Given a thing (field value in a struct), set the thing with the element in the map (key)
	the map value to the proper type.
*/
func set_value(thing reflect.Value, kind reflect.Kind, key string, tag_id string, pfx string, annon bool, m map[string]string) {

	if !thing.CanAddr() { // prevent stack dump
		return
	}

	switch kind {
	default:
		fmt.Fprintf(os.Stderr, "transform.mts: tagged sturct member cannot be converted from map: tag=%s kind=%v\n", key, thing.Kind())

	case reflect.String:
		thing.SetString(m[key])

	case reflect.Ptr:
		p := thing.Elem() // get the pointer value; allows us to suss the type
		if !p.IsValid() { // ptr is nill in the struct so we must allocate a pointer to 0 so it can be changed below
			thing.Set(reflect.New(thing.Type().Elem()))
			p = thing.Elem()
		}
		switch p.Kind() {
		case reflect.String:
			s := m[key] // copy it and then point to the copy
			thing.Set(reflect.ValueOf(&s))

		case reflect.Int:
			i := clike.Atoi(m[key]) // convert to integer and then point at the value
			thing.Set(reflect.ValueOf(&i))

		case reflect.Int64:
			i := clike.Atoi64(m[key])
			thing.Set(reflect.ValueOf(&i))

		case reflect.Int32:
			i := clike.Atoi32(m[key])
			thing.Set(reflect.ValueOf(&i))

		case reflect.Int16:
			i := clike.Atoi16(m[key])
			thing.Set(reflect.ValueOf(&i))

		case reflect.Int8:
			i := int8(clike.Atoi16(m[key]))
			thing.Set(reflect.ValueOf(&i))

		case reflect.Uint:
			ui := clike.Atou(m[key])
			thing.Set(reflect.ValueOf(&ui))

		case reflect.Uint64:
			ui := clike.Atou64(m[key])
			thing.Set(reflect.ValueOf(&ui))

		case reflect.Uint32:
			ui := clike.Atou32(m[key])
			thing.Set(reflect.ValueOf(&ui))

		case reflect.Uint16:
			ui := clike.Atou16(m[key])
			thing.Set(reflect.ValueOf(&ui))

		case reflect.Uint8:
			ui := uint8(clike.Atou16(m[key]))
			thing.Set(reflect.ValueOf(&ui))

		case reflect.Float64:
			fv := clike.Atof(m[key])
			thing.Set(reflect.ValueOf(&fv))

		case reflect.Float32:
			fv := float32(clike.Atof(m[key]))
			thing.Set(reflect.ValueOf(&fv))

		case reflect.Bool:
			b := m[key] == "true" || m[key] == "True" || m[key] == "TRUE"
			thing.Set(reflect.ValueOf(&b))

		case reflect.Struct:
			map_to_struct(m, p, p.Type(), tag_id, pfx) // recurse to process
		}

	case reflect.Int, reflect.Int64, reflect.Int32, reflect.Int16, reflect.Int8:
		thing.SetInt(clike.Atoi64(m[key]))

	case reflect.Uint, reflect.Uint64, reflect.Uint32, reflect.Uint16, reflect.Uint8:
		thing.SetUint(uint64(clike.Atoi64(m[key])))

	case reflect.Float64, reflect.Float32:
		thing.SetFloat(clike.Atof(m[key]))

	case reflect.Bool:
		thing.SetBool(m[key] == "true")

	case reflect.Map:
		new_map := reflect.MakeMap(thing.Type()) // create the map
		thing.Set(new_map)                       // put it in the struct

		idx := key + "/" // now populate the map
		ilen := len(idx)
		for k, _ := range m { // we could keep a separate list of keys, but for now this should do
			if strings.HasPrefix(k, key) {
				tokens := strings.Split(k[ilen:], "/")
				map_key := reflect.ValueOf(tokens[0]) // map key is everything past the tag to the next slant
				map_ele_type := new_map.Type().Elem() // the type of the element that the map references

				mthing := reflect.New(map_ele_type).Elem() // new returns pointer, so dereference with Elem() (value not type!)

				set_value(mthing, mthing.Kind(), idx+tokens[0], tag_id, idx+tokens[0]+"/", false, m) // put the value into the map thing
				new_map.SetMapIndex(map_key, mthing)                                                 // put it into the map (order IS important; add to map after recursion)
				//fmt.Fprintf( os.Stderr, "saving: %s  thing-type=%s mthing=%s\n", map_key, thing.Type(), mthing )
			}
		}

	case reflect.Slice:
		c := clike.Atoi(m[key+".cap"])
		l := clike.Atoi(m[key+".len"])

		thing.Set(reflect.MakeSlice(thing.Type(), l, c)) // create a new slice with the same len/cap that it had
		for j := 0; j < l; j++ {
			idx := fmt.Sprintf("%s/%d", key, j)
			set_value(thing.Index(j), thing.Type().Elem().Kind(), idx, tag_id, idx+"/", false, m) // populate each value of the slice up to len
		}

	case reflect.Struct:
		if annon {
			map_to_struct(m, thing, thing.Type(), tag_id, key) // anon structs share namespace, so prefix is the same
		} else {
			map_to_struct(m, thing, thing.Type(), tag_id, pfx) // dive to get the substruct adding a level to the prefix
		}

	}

}