mirror of
https://gitee.com/energye/energy.git
synced 2024-11-30 10:47:57 +08:00
396 lines
12 KiB
Go
396 lines
12 KiB
Go
//----------------------------------------
|
|
//
|
|
// Copyright © yanghy. All Rights Reserved.
|
|
//
|
|
// Licensed under Apache License Version 2.0, January 2004
|
|
//
|
|
// https://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
//----------------------------------------
|
|
|
|
//ValueConvert 值转换
|
|
// 进程消息、V8Value、Go类型
|
|
package cef
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"github.com/energye/energy/consts"
|
|
"reflect"
|
|
)
|
|
|
|
func goValueConvert(result *ICefListValue, i uint32, value interface{}) {
|
|
switch value.(type) {
|
|
case bool:
|
|
result.SetBool(i, value.(bool))
|
|
case float32:
|
|
result.SetDouble(i, float64(value.(float32)))
|
|
case float64:
|
|
result.SetDouble(i, value.(float64))
|
|
case string:
|
|
result.SetString(i, value.(string))
|
|
case int:
|
|
result.SetInt(i, int32(value.(int)))
|
|
case int8:
|
|
result.SetInt(i, int32(value.(int8)))
|
|
case int16:
|
|
result.SetInt(i, int32(value.(int16)))
|
|
case int32:
|
|
result.SetInt(i, value.(int32))
|
|
case int64:
|
|
result.SetString(i, fmt.Sprintf("%d", value.(int64)))
|
|
case uint:
|
|
result.SetInt(i, int32(value.(uint)))
|
|
case uint8:
|
|
result.SetInt(i, int32(value.(uint8)))
|
|
case uint16:
|
|
result.SetInt(i, int32(value.(uint16)))
|
|
case uint32:
|
|
result.SetInt(i, int32(value.(uint32)))
|
|
case uint64:
|
|
result.SetString(i, fmt.Sprintf("%d", value.(uint64)))
|
|
default:
|
|
result.SetNull(i)
|
|
}
|
|
}
|
|
|
|
//goValueToListValue GoValue 转换 ICefListValue
|
|
func goValueToListValue(data []interface{}) (*ICefListValue, error) {
|
|
if data == nil {
|
|
return nil, errors.New("build process message error. Parameter null")
|
|
}
|
|
var result = ListValueRef.New()
|
|
|
|
for i, value := range data {
|
|
if value == nil {
|
|
result.SetNull(uint32(i))
|
|
continue
|
|
}
|
|
var typeOf = reflect.TypeOf(value)
|
|
switch typeOf.Kind() {
|
|
case reflect.Slice: // array
|
|
fmt.Println("goValueToListValue Slice")
|
|
switch value.(type) {
|
|
case []bool:
|
|
var list = ListValueRef.New()
|
|
for i, v := range value.([]bool) {
|
|
list.SetBool(uint32(i), v)
|
|
}
|
|
result.SetList(uint32(i), list)
|
|
case []float32:
|
|
var list = ListValueRef.New()
|
|
for i, v := range value.([]float32) {
|
|
list.SetDouble(uint32(i), float64(v))
|
|
}
|
|
result.SetList(uint32(i), list)
|
|
case []float64:
|
|
var list = ListValueRef.New()
|
|
for i, v := range value.([]float64) {
|
|
list.SetDouble(uint32(i), v)
|
|
}
|
|
result.SetList(uint32(i), list)
|
|
case []string:
|
|
var list = ListValueRef.New()
|
|
for i, v := range value.([]string) {
|
|
list.SetString(uint32(i), v)
|
|
}
|
|
result.SetList(uint32(i), list)
|
|
case []int:
|
|
var list = ListValueRef.New()
|
|
for i, v := range value.([]int) {
|
|
list.SetInt(uint32(i), int32(v))
|
|
}
|
|
result.SetList(uint32(i), list)
|
|
case []int8:
|
|
var list = ListValueRef.New()
|
|
for i, v := range value.([]int8) {
|
|
list.SetInt(uint32(i), int32(v))
|
|
}
|
|
result.SetList(uint32(i), list)
|
|
case []int16:
|
|
var list = ListValueRef.New()
|
|
for i, v := range value.([]int16) {
|
|
list.SetInt(uint32(i), int32(v))
|
|
}
|
|
result.SetList(uint32(i), list)
|
|
case []int32:
|
|
var list = ListValueRef.New()
|
|
for i, v := range value.([]int32) {
|
|
list.SetInt(uint32(i), v)
|
|
}
|
|
result.SetList(uint32(i), list)
|
|
case []int64:
|
|
var list = ListValueRef.New()
|
|
for i, v := range value.([]int64) {
|
|
list.SetString(uint32(i), fmt.Sprintf("%d", v))
|
|
}
|
|
result.SetList(uint32(i), list)
|
|
case []uint:
|
|
var list = ListValueRef.New()
|
|
for i, v := range value.([]uint) {
|
|
list.SetInt(uint32(i), int32(v))
|
|
}
|
|
result.SetList(uint32(i), list)
|
|
case []uint8:
|
|
BinaryValueRef.New(value.([]byte))
|
|
result.SetBinary(uint32(i), BinaryValueRef.New(value.([]byte)))
|
|
case []uint16:
|
|
var list = ListValueRef.New()
|
|
for i, v := range value.([]uint16) {
|
|
list.SetInt(uint32(i), int32(v))
|
|
}
|
|
result.SetList(uint32(i), list)
|
|
case []uint32:
|
|
var list = ListValueRef.New()
|
|
for i, v := range value.([]uint32) {
|
|
list.SetInt(uint32(i), int32(v))
|
|
}
|
|
result.SetList(uint32(i), list)
|
|
case []uint64:
|
|
var list = ListValueRef.New()
|
|
for i, v := range value.([]uint64) {
|
|
list.SetString(uint32(i), fmt.Sprintf("%d", v))
|
|
}
|
|
result.SetList(uint32(i), list)
|
|
case []interface{}:
|
|
if v, err := goValueToListValue(value.([]interface{})); err == nil {
|
|
result.SetList(uint32(i), v)
|
|
} else {
|
|
result.SetList(uint32(i), ListValueRef.New())
|
|
}
|
|
default:
|
|
sliceTypeOf := typeOf.Elem()
|
|
sliceKind := sliceTypeOf.Kind()
|
|
fmt.Println("sliceTypeOf", sliceTypeOf.Kind())
|
|
if sliceKind == reflect.Ptr {
|
|
sliceTypeOf = sliceTypeOf.Elem()
|
|
}
|
|
fmt.Println("\t", sliceTypeOf.Kind())
|
|
rv := reflect.ValueOf(value)
|
|
if sliceTypeOf.Kind() == reflect.Struct {
|
|
sliceListValue := ListValueRef.New()
|
|
for i := 0; i < rv.Len(); i++ {
|
|
sliceListValue.SetDictionary(uint32(i), goStructValueToDictionaryValue(rv.Index(i)))
|
|
}
|
|
fmt.Println("\t\tStruct len:", rv.Len())
|
|
result.SetList(uint32(i), sliceListValue)
|
|
} else if sliceTypeOf.Kind() == reflect.Map {
|
|
fmt.Println("\t\tMap len:", rv.Len())
|
|
} else {
|
|
result.SetList(uint32(i), ListValueRef.New())
|
|
}
|
|
}
|
|
case reflect.Map: // object
|
|
fmt.Println("goValueToListValue Map")
|
|
case reflect.Struct: // object
|
|
fmt.Println("goValueToListValue Struct")
|
|
default:
|
|
fmt.Println("goValueToListValue default", value)
|
|
goValueConvert(result, uint32(i), value)
|
|
}
|
|
}
|
|
return result, nil
|
|
}
|
|
|
|
// goStructValueToDictionaryValue Go结构转字典
|
|
func goStructValueToDictionaryValue(rv reflect.Value) *ICefDictionaryValue {
|
|
rt := rv.Type()
|
|
if rt.Kind() == reflect.Ptr {
|
|
rt = rt.Elem()
|
|
}
|
|
result := DictionaryValueRef.New()
|
|
nf := rt.NumField()
|
|
fmt.Println("nf", nf)
|
|
|
|
return result
|
|
}
|
|
|
|
//listValueToV8Value ICefListValue 转换 ICefV8Value
|
|
func listValueToV8Value(list *ICefListValue) (*ICefV8Value, error) {
|
|
if list == nil {
|
|
return nil, errors.New("build v8 value error. Parameter null")
|
|
}
|
|
size := int(list.Size())
|
|
result := V8ValueRef.NewArray(int32(size))
|
|
for i := 0; i < size; i++ {
|
|
value := list.GetValue(uint32(i))
|
|
var newValue *ICefV8Value
|
|
switch value.GetType() {
|
|
case consts.VTYPE_NULL:
|
|
newValue = V8ValueRef.NewNull()
|
|
case consts.VTYPE_BOOL:
|
|
newValue = V8ValueRef.NewBool(value.GetBool())
|
|
case consts.VTYPE_INT:
|
|
newValue = V8ValueRef.NewInt(value.GetInt())
|
|
case consts.VTYPE_DOUBLE:
|
|
newValue = V8ValueRef.NewDouble(value.GetDouble())
|
|
case consts.VTYPE_STRING:
|
|
newValue = V8ValueRef.NewString(value.GetString())
|
|
case consts.VTYPE_BINARY: // []byte
|
|
//newValue = V8ValueRef.NewArrayBuffer(value.GetBinary())
|
|
case consts.VTYPE_DICTIONARY: // Object
|
|
if v, err := dictionaryValueToV8Value(value.GetDictionary()); err == nil {
|
|
newValue = v
|
|
}
|
|
case consts.VTYPE_LIST: // Array
|
|
if v, err := listValueToV8Value(value.GetList()); err == nil {
|
|
newValue = v
|
|
}
|
|
}
|
|
if newValue != nil {
|
|
result.SetValueByIndex(int32(i), newValue)
|
|
}
|
|
}
|
|
return result, nil
|
|
}
|
|
|
|
//dictionaryValueToV8Value ICefDictionaryValue 转换 ICefV8Value
|
|
func dictionaryValueToV8Value(dictionary *ICefDictionaryValue) (*ICefV8Value, error) {
|
|
if dictionary == nil {
|
|
return nil, errors.New("build v8 value error. Parameter null")
|
|
}
|
|
keys := dictionary.GetKeys()
|
|
//bindSubObjectAccessor := V8AccessorRef.New()
|
|
//bindSubObjectAccessor.Get(ctx.bindSubObjectGet)
|
|
//bindSubObjectAccessor.Set(ctx.bindSubObjectSet)
|
|
result := V8ValueRef.NewObject(nil)
|
|
for i := 0; i < keys.Count(); i++ {
|
|
key := keys.Get(i)
|
|
value := dictionary.GetValue(key)
|
|
var newValue *ICefV8Value
|
|
switch value.GetType() {
|
|
case consts.VTYPE_NULL:
|
|
newValue = V8ValueRef.NewNull()
|
|
case consts.VTYPE_BOOL:
|
|
newValue = V8ValueRef.NewBool(value.GetBool())
|
|
case consts.VTYPE_INT:
|
|
newValue = V8ValueRef.NewInt(value.GetInt())
|
|
case consts.VTYPE_DOUBLE:
|
|
newValue = V8ValueRef.NewDouble(value.GetDouble())
|
|
case consts.VTYPE_STRING:
|
|
newValue = V8ValueRef.NewString(value.GetString())
|
|
case consts.VTYPE_BINARY: // []byte
|
|
case consts.VTYPE_DICTIONARY: // Object
|
|
if v, err := dictionaryValueToV8Value(value.GetDictionary()); err == nil {
|
|
newValue = v
|
|
}
|
|
case consts.VTYPE_LIST: // Array
|
|
if v, err := listValueToV8Value(value.GetList()); err == nil {
|
|
newValue = v
|
|
}
|
|
}
|
|
if newValue != nil {
|
|
result.setValueByAccessor(key, consts.V8_ACCESS_CONTROL_DEFAULT, consts.V8_PROPERTY_ATTRIBUTE_NONE)
|
|
result.setValueByKey(key, newValue, consts.V8_PROPERTY_ATTRIBUTE_NONE)
|
|
}
|
|
}
|
|
return result, nil
|
|
}
|
|
|
|
// v8ValueToProcessMessage ICefV8Value 转换 ICefListValue
|
|
func v8ValueToProcessMessage(v8value *ICefV8Value) (*ICefListValue, error) {
|
|
if v8value == nil {
|
|
return nil, errors.New("build process message error. Parameter null")
|
|
}
|
|
if v8value.IsArray() {
|
|
return v8valueArrayEncode(v8value)
|
|
} else if v8value.IsObject() {
|
|
if v, err := v8valueObjectEncode(v8value); err == nil {
|
|
arrayValue := ListValueRef.New()
|
|
arrayValue.SetDictionary(uint32(0), v)
|
|
return arrayValue, nil
|
|
} else {
|
|
return nil, err
|
|
}
|
|
} else {
|
|
arrayValue := ListValueRef.New()
|
|
if v8value.IsString() {
|
|
arrayValue.SetString(uint32(0), v8value.GetStringValue())
|
|
} else if v8value.IsInt() {
|
|
arrayValue.SetInt(uint32(0), v8value.GetIntValue())
|
|
} else if v8value.IsUInt() {
|
|
arrayValue.SetInt(uint32(0), int32(v8value.GetUIntValue()))
|
|
} else if v8value.IsDouble() {
|
|
arrayValue.SetDouble(uint32(0), v8value.GetDoubleValue())
|
|
} else if v8value.IsBool() {
|
|
arrayValue.SetBool(uint32(0), v8value.GetBoolValue())
|
|
} else {
|
|
arrayValue.SetNull(uint32(0))
|
|
}
|
|
return arrayValue, nil
|
|
}
|
|
}
|
|
|
|
// v8valueArrayEncode ICefV8Value 转换 ICefListValue
|
|
func v8valueArrayEncode(v8value *ICefV8Value) (*ICefListValue, error) {
|
|
if !v8value.IsArray() {
|
|
return nil, errors.New("build process message error. Please pass in the array type")
|
|
}
|
|
arrayValue := ListValueRef.New()
|
|
argsLen := v8value.GetArrayLength()
|
|
for i := 0; i < argsLen; i++ {
|
|
args := v8value.GetValueByIndex(i)
|
|
if args.IsString() {
|
|
arrayValue.SetString(uint32(i), args.GetStringValue())
|
|
} else if args.IsInt() {
|
|
arrayValue.SetInt(uint32(i), args.GetIntValue())
|
|
} else if args.IsUInt() {
|
|
arrayValue.SetInt(uint32(i), int32(args.GetUIntValue()))
|
|
} else if args.IsDouble() {
|
|
arrayValue.SetDouble(uint32(i), args.GetDoubleValue())
|
|
} else if args.IsBool() {
|
|
arrayValue.SetBool(uint32(i), args.GetBoolValue())
|
|
} else if args.IsNull() || args.IsUndefined() {
|
|
arrayValue.SetNull(uint32(i))
|
|
} else if args.IsArray() {
|
|
if v, err := v8valueArrayEncode(args); err == nil {
|
|
arrayValue.SetList(uint32(i), v)
|
|
}
|
|
} else if args.IsObject() {
|
|
if v, err := v8valueObjectEncode(args); err == nil {
|
|
arrayValue.SetDictionary(uint32(i), v)
|
|
}
|
|
} else {
|
|
arrayValue.SetNull(uint32(i))
|
|
}
|
|
}
|
|
return arrayValue, nil
|
|
}
|
|
|
|
// v8valueObjectEncode ICefV8Value 转换 ICefDictionaryValue
|
|
func v8valueObjectEncode(v8value *ICefV8Value) (*ICefDictionaryValue, error) {
|
|
if !v8value.IsObject() {
|
|
return nil, errors.New("build process message error. Please pass in the object type")
|
|
}
|
|
dictionaryValue := DictionaryValueRef.New()
|
|
keys := v8value.GetKeys()
|
|
for i := 0; i < keys.Count(); i++ {
|
|
key := keys.Get(i)
|
|
args := v8value.GetValueByKey(key)
|
|
if args.IsString() {
|
|
dictionaryValue.SetString(key, args.GetStringValue())
|
|
} else if args.IsInt() {
|
|
dictionaryValue.SetInt(key, args.GetIntValue())
|
|
} else if args.IsUInt() {
|
|
dictionaryValue.SetInt(key, int32(args.GetUIntValue()))
|
|
} else if args.IsDouble() {
|
|
dictionaryValue.SetDouble(key, args.GetDoubleValue())
|
|
} else if args.IsBool() {
|
|
dictionaryValue.SetBool(key, args.GetBoolValue())
|
|
} else if args.IsNull() || args.IsUndefined() {
|
|
dictionaryValue.SetNull(key)
|
|
} else if args.IsArray() {
|
|
if v, err := v8valueArrayEncode(args); err == nil {
|
|
dictionaryValue.SetList(key, v)
|
|
}
|
|
} else if args.IsObject() {
|
|
if v, err := v8valueObjectEncode(args); err == nil {
|
|
dictionaryValue.SetDictionary(key, v)
|
|
}
|
|
} else {
|
|
dictionaryValue.SetNull(key)
|
|
}
|
|
}
|
|
return dictionaryValue, nil
|
|
}
|