Golang C.g_value_get_enum函数代码示例

func fromGValue(v *C.GValue) (ret interface{}) {
	valueType := C.gvalue_get_type(v)
	fundamentalType := C.gtype_get_fundamental(valueType)
	switch fundamentalType {
	case C.G_TYPE_OBJECT:
		ret = unsafe.Pointer(C.g_value_get_object(v))
	case C.G_TYPE_STRING:
		ret = fromGStr(C.g_value_get_string(v))
	case C.G_TYPE_UINT:
		ret = int(C.g_value_get_uint(v))
	case C.G_TYPE_BOXED:
		ret = unsafe.Pointer(C.g_value_get_boxed(v))
	case C.G_TYPE_BOOLEAN:
		ret = C.g_value_get_boolean(v) == C.gboolean(1)
	case C.G_TYPE_ENUM:
		ret = int(C.g_value_get_enum(v))
	default:
		panic(fmt.Sprintf("from type %s %T", fromGStr(C.g_type_name(fundamentalType)), v))
	}
	return
}

func marshalWrapMode(p uintptr) (interface{}, error) {
	c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p)))
	return WrapMode(c), nil
}

func marshalStateChangeReturn(p uintptr) (interface{}, error) {
	c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p)))
	return StateChangeReturn(c), nil
}

func marshalSeekFlags(p uintptr) (interface{}, error) {
	c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p)))
	return SeekFlags(c), nil
}

func marshalPadLinkReturn(p uintptr) (interface{}, error) {
	c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p)))
	return PadLinkReturn(c), nil
}

func marshalMessageType(p uintptr) (interface{}, error) {
	c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p)))
	return MessageType(c), nil
}

func marshalOperator(p uintptr) (interface{}, error) {
	c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p)))
	return Operator(c), nil
}

func marshalStackTransitionType(p uintptr) (interface{}, error) {
	c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p)))
	return StackTransitionType(c), nil
}

func marshalAlignment(p uintptr) (interface{}, error) {
	c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p)))
	return Alignment(c), nil
}

func marshalTLSErrorsPolicy(p uintptr) (interface{}, error) {
	c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p)))
	return TLSErrorsPolicy(c), nil
}

func marshalProcessModel(p uintptr) (interface{}, error) {
	c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p)))
	return ProcessModel(c), nil
}

// GoValue() converts a Value to comparable Go type.  GoValue()
// returns a non-nil error if the conversion was unsuccessful.  The
// returned interface{} must be type asserted as the actual Go
// representation of the Value.
//
// This function is a wrapper around the many g_value_get_*()
// functions, depending on the type of the Value.
func (v *Value) GoValue() (interface{}, error) {
	_, fundamental, err := v.Type()
	if err != nil {
		return nil, err
	}

	// TODO: verify that all of these cases are indeed fundamental types
	switch fundamental {
	case TYPE_INVALID:
		return nil, errors.New("invalid type")

	case TYPE_NONE:
		return nil, nil

	case TYPE_INTERFACE:
		return nil, errors.New("interface conversion not yet implemented")

	case TYPE_CHAR:
		c := C.g_value_get_schar(v.Native())
		return int8(c), nil

	case TYPE_UCHAR:
		c := C.g_value_get_uchar(v.Native())
		return uint8(c), nil

	case TYPE_BOOLEAN:
		c := C.g_value_get_boolean(v.Native())
		return gobool(c), nil

	// TODO: TYPE_INT should probably be a Go int32.
	case TYPE_INT, TYPE_LONG:
		c := C.g_value_get_int(v.Native())
		return int(c), nil

	case TYPE_ENUM:
		c := C.g_value_get_enum(v.Native())
		return int(c), nil

	case TYPE_INT64:
		c := C.g_value_get_int64(v.Native())
		return int64(c), nil

	// TODO: TYPE_UINT should probably be a Go uint32.
	case TYPE_UINT, TYPE_ULONG, TYPE_FLAGS:
		c := C.g_value_get_uint(v.Native())
		return uint(c), nil

	case TYPE_UINT64:
		c := C.g_value_get_uint64(v.Native())
		return uint64(c), nil

	case TYPE_FLOAT:
		c := C.g_value_get_float(v.Native())
		return float32(c), nil

	case TYPE_DOUBLE:
		c := C.g_value_get_double(v.Native())
		return float64(c), nil

	case TYPE_STRING:
		c := C.g_value_get_string(v.Native())
		return C.GoString((*C.char)(c)), nil

	case TYPE_POINTER:
		c := C.g_value_get_pointer(v.Native())
		return unsafe.Pointer(c), nil

	case TYPE_OBJECT:
		c := C.g_value_get_object(v.Native())
		// TODO: need to try and return an actual pointer to the correct object type
		// this may require an additional cast()-like method for each module
		return ObjectNew(unsafe.Pointer(c)), nil

	case TYPE_VARIANT:
		return nil, errors.New("variant conversion not yet implemented")

	default:
		return nil, errors.New("type conversion not supported")
	}
}

func marshalDragAction(p uintptr) (interface{}, error) {
	c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p)))
	return DragAction(c), nil
}

func marshalEventMask(p uintptr) (interface{}, error) {
	c := C.g_value_get_enum((*C.GValue)(unsafe.Pointer(p)))
	return EventMask(c), nil
}