Exemple #1
0
// Reads a single arbitrary type and returns the proper StateValue.
func readField(val reflect.Value) *protocol.StateValue {
	msg := &protocol.StateValue{}
	switch f := val.(type) {
	case *reflect.BoolValue:
		msg.Type = protocol.NewStateValue_Type(protocol.StateValue_BOOL)
		msg.BoolVal = proto.Bool(f.Get())
	case *reflect.IntValue:
		msg.Type = protocol.NewStateValue_Type(protocol.StateValue_INT)
		msg.IntVal = proto.Int(int(f.Get()))
	case *reflect.FloatValue:
		msg.Type = protocol.NewStateValue_Type(protocol.StateValue_FLOAT)
		msg.FloatVal = proto.Float32(float32(f.Get()))
	case *reflect.StringValue:
		msg.Type = protocol.NewStateValue_Type(protocol.StateValue_STRING)
		msg.StringVal = proto.String(f.Get())
	case *reflect.SliceValue:
		msg.Type = protocol.NewStateValue_Type(protocol.StateValue_ARRAY)
		msg.ArrayVal = makeStateValueArray(f, f.Len())
	case *reflect.StructValue:
		msg = readStructField(f)
	case *reflect.PtrValue:
		return readField(reflect.Indirect(f)) // Dereference and recurse
	default:
		panic("State value not supported: " + val.Type().String())
	}
	return msg
}
Exemple #2
0
func TestV3FieldState(t *testing.T) {
	vec := s3dm.V3{9, 9, 9}
	state := v3FieldState{vec}
	sv := &protocol.StateValue{}
	sv.Type = protocol.NewStateValue_Type(protocol.StateValue_VECTOR3)
	sv.Vector3Val = &protocol.Vector3{&vec.X, &vec.Y, &vec.Z, nil}

	equalOrError(t, sv, packState(state))
}
Exemple #3
0
func TestPtrFieldState(t *testing.T) {
	num := 9
	state := ptrFieldState{&num}
	sv := &protocol.StateValue{}
	sv.Type = protocol.NewStateValue_Type(protocol.StateValue_INT)
	sv.IntVal = proto.Int(*state.Value)

	equalOrError(t, sv, packState(state))
}
Exemple #4
0
func TestSingleFieldState(t *testing.T) {
	// testState is made available by observer_test.go
	state := testState{9}
	sv := &protocol.StateValue{}
	sv.Type = protocol.NewStateValue_Type(protocol.StateValue_INT)
	sv.IntVal = proto.Int(state.Value)

	equalOrError(t, sv, packState(state))
}
Exemple #5
0
func TestMultipleFieldState(t *testing.T) {
	a, b := 1, 2
	state := multipleFieldState{a, b}
	sv := &protocol.StateValue{}
	sv.Type = protocol.NewStateValue_Type(protocol.StateValue_ARRAY)

	inner_v1 := makeIntValMsg(a)
	inner_v2 := makeIntValMsg(b)
	sv.ArrayVal = append([]*protocol.StateValue{}, inner_v1, inner_v2)

	equalOrError(t, sv, packState(state))
}
Exemple #6
0
// Makes a Vector3 StateValue. Panics if the StructValue fields do not match the vector.
func makeVector3(v *reflect.StructValue) *protocol.StateValue {
	// If we panic here, struct layout was not as expected
	x := v.FieldByName("X").(*reflect.FloatValue).Get()
	y := v.FieldByName("Y").(*reflect.FloatValue).Get()
	z := v.FieldByName("Z").(*reflect.FloatValue).Get()

	vector3 := &protocol.Vector3{&x, &y, &z, nil}
	sv := &protocol.StateValue{
		Type:       protocol.NewStateValue_Type(protocol.StateValue_VECTOR3),
		Vector3Val: vector3,
	}
	return sv
}
Exemple #7
0
func TestSliceFieldState(t *testing.T) {
	s := []int{1, 2, 3, 4, 5}
	state := sliceFieldState{s}
	sv := &protocol.StateValue{}
	sv.Type = protocol.NewStateValue_Type(protocol.StateValue_ARRAY)

	msgs := make([]*protocol.StateValue, 0, len(s))
	for _, i := range s {
		msgs = append(msgs, makeIntValMsg(i))
	}
	sv.ArrayVal = msgs

	equalOrError(t, sv, packState(state))
}
Exemple #8
0
// Creates the right type of StateValue message for an arbitrary State type.
func packState(state State) (msg *protocol.StateValue) {
	val := reflect.NewValue(state)
	state_v, ok := val.(*reflect.StructValue)
	if !ok {
		panic("State is non-struct type!")
	}

	field_num := state_v.NumField()
	if field_num > 1 { // If we have multiple fields, treat as array
		msg = &protocol.StateValue{}
		msg.Type = protocol.NewStateValue_Type(protocol.StateValue_ARRAY)
		msg.ArrayVal = makeStateValueArray(state_v, field_num)
	} else { // Single field
		msg = readField(state_v.Field(0))
	}
	return msg
}
Exemple #9
0
// Returns a StateValue with IntVal set to the passed value x
func makeIntValMsg(x int) *protocol.StateValue {
	sv := &protocol.StateValue{}
	sv.Type = protocol.NewStateValue_Type(protocol.StateValue_INT)
	sv.IntVal = proto.Int(x)
	return sv
}