github.com/GuanceCloud/cliutils@v1.1.21/point/val.go (about)

     1  package point
     2  
     3  import types "github.com/gogo/protobuf/types"
     4  
     5  func setVal(v isField_Val, raw any) isField_Val {
     6  	switch f := v.(type) {
     7  	case *Field_I:
     8  		switch x := raw.(type) {
     9  		case int8:
    10  			f.I = int64(x)
    11  		case int16:
    12  			f.I = int64(x)
    13  		case int32:
    14  			f.I = int64(x)
    15  		case int64:
    16  			f.I = x
    17  		case int:
    18  			f.I = int64(x)
    19  		}
    20  
    21  	case *Field_U:
    22  		switch x := raw.(type) {
    23  		case uint8:
    24  			f.U = uint64(x)
    25  		case uint16:
    26  			f.U = uint64(x)
    27  		case uint32:
    28  			f.U = uint64(x)
    29  		case uint64:
    30  			f.U = x
    31  		case uint:
    32  			f.U = uint64(x)
    33  		}
    34  
    35  	case *Field_F:
    36  		switch x := raw.(type) {
    37  		case float64:
    38  			f.F = x
    39  		case float32:
    40  			f.F = float64(x)
    41  		}
    42  
    43  	case *Field_S:
    44  		if x, ok := raw.(string); ok {
    45  			f.S = x
    46  		}
    47  
    48  	case *Field_D:
    49  		if x, ok := raw.([]byte); ok {
    50  			f.D = f.D[:0] // reset
    51  			f.D = append(f.D, x...)
    52  		}
    53  
    54  	case *Field_B:
    55  		if x, ok := raw.(bool); ok {
    56  			f.B = x
    57  		}
    58  
    59  	case *Field_A:
    60  		var (
    61  			arr *types.Any
    62  			err error
    63  		)
    64  
    65  		switch x := raw.(type) {
    66  		case []int8:
    67  			arr, err = NewIntArray(x...)
    68  		case []int16:
    69  			arr, err = NewIntArray(x...)
    70  		case []int32:
    71  			arr, err = NewIntArray(x...)
    72  		case []int64:
    73  			arr, err = NewIntArray(x...)
    74  		case []int:
    75  			arr, err = NewIntArray(x...)
    76  
    77  		case []uint16:
    78  			arr, err = NewUintArray(x...)
    79  		case []uint32:
    80  			arr, err = NewUintArray(x...)
    81  		case []uint64:
    82  			arr, err = NewUintArray(x...)
    83  
    84  		case []string:
    85  			arr, err = NewStringArray(x...)
    86  
    87  		case []bool:
    88  			arr, err = NewBoolArray(x...)
    89  
    90  		case [][]byte:
    91  			arr, err = NewBytesArray(x...)
    92  
    93  		case *types.Any:
    94  			arr = x
    95  		default:
    96  			// do nothing
    97  		}
    98  
    99  		if err == nil {
   100  			f.A = arr
   101  		}
   102  	}
   103  
   104  	// NOTE: if raw is nil or other types, do nothing
   105  	return v
   106  }
   107  
   108  func newVal(v any) isField_Val {
   109  	switch x := v.(type) {
   110  	case int8:
   111  		return &Field_I{int64(x)}
   112  	case []int8:
   113  		iarr, err := NewIntArray(x...)
   114  		if err != nil {
   115  			return nil
   116  		} else {
   117  			return &Field_A{iarr}
   118  		}
   119  
   120  	case uint8:
   121  		return &Field_U{uint64(x)}
   122  		// case []uint8 is []byte, skip it.
   123  
   124  	case int16:
   125  		return &Field_I{int64(x)}
   126  
   127  	case []int16:
   128  		iarr, err := NewIntArray(x...)
   129  		if err != nil {
   130  			return nil
   131  		} else {
   132  			return &Field_A{iarr}
   133  		}
   134  
   135  	case uint16:
   136  		return &Field_U{uint64(x)}
   137  
   138  	case []uint16:
   139  		iarr, err := NewUintArray(x...)
   140  		if err != nil {
   141  			return nil
   142  		} else {
   143  			return &Field_A{iarr}
   144  		}
   145  
   146  	case int32:
   147  		return &Field_I{int64(x)}
   148  
   149  	case []int32:
   150  		iarr, err := NewIntArray(x...)
   151  		if err != nil {
   152  			return nil
   153  		} else {
   154  			return &Field_A{iarr}
   155  		}
   156  
   157  	case uint32:
   158  		return &Field_U{uint64(x)}
   159  
   160  	case []uint32:
   161  		iarr, err := NewUintArray(x...)
   162  		if err != nil {
   163  			return nil
   164  		} else {
   165  			return &Field_A{iarr}
   166  		}
   167  
   168  	case int:
   169  		return &Field_I{int64(x)}
   170  
   171  	case []int:
   172  		iarr, err := NewIntArray(x...)
   173  		if err != nil {
   174  			return nil
   175  		} else {
   176  			return &Field_A{iarr}
   177  		}
   178  
   179  	case uint:
   180  		return &Field_U{uint64(x)}
   181  
   182  	case []uint:
   183  		iarr, err := NewUintArray(x...)
   184  		if err != nil {
   185  			return nil
   186  		} else {
   187  			return &Field_A{iarr}
   188  		}
   189  
   190  	case int64:
   191  		return &Field_I{x}
   192  
   193  	case []int64:
   194  		iarr, err := NewIntArray(x...)
   195  		if err != nil {
   196  			return nil
   197  		} else {
   198  			return &Field_A{iarr}
   199  		}
   200  
   201  	case uint64:
   202  		return &Field_U{x}
   203  
   204  	case []uint64:
   205  		iarr, err := NewUintArray(x...)
   206  		if err != nil {
   207  			return nil
   208  		} else {
   209  			return &Field_A{iarr}
   210  		}
   211  
   212  	case float64:
   213  		return &Field_F{x}
   214  
   215  	case []float64:
   216  		farr, err := NewFloatArray(x...)
   217  		if err != nil {
   218  			return nil
   219  		} else {
   220  			return &Field_A{farr}
   221  		}
   222  
   223  	case float32:
   224  		return &Field_F{float64(x)}
   225  
   226  	case []float32:
   227  		farr, err := NewFloatArray(x...)
   228  		if err != nil {
   229  			return nil
   230  		} else {
   231  			return &Field_A{farr}
   232  		}
   233  
   234  	case string:
   235  		return &Field_S{x}
   236  
   237  	case []string:
   238  		sarr, err := NewStringArray(x...)
   239  		if err != nil {
   240  			return nil
   241  		} else {
   242  			return &Field_A{sarr}
   243  		}
   244  
   245  	case []byte:
   246  		return &Field_D{x}
   247  
   248  	case [][]byte:
   249  		bytesArr, err := NewBytesArray(x...)
   250  		if err != nil {
   251  			return nil
   252  		} else {
   253  			return &Field_A{bytesArr}
   254  		}
   255  
   256  	case bool:
   257  		return &Field_B{x}
   258  
   259  	case []bool:
   260  		barr, err := NewBoolArray(x...)
   261  		if err != nil {
   262  			return nil
   263  		} else {
   264  			return &Field_A{barr}
   265  		}
   266  
   267  	case []any:
   268  		arr, err := NewAnyArray(x...)
   269  		if err != nil {
   270  			return nil
   271  		} else {
   272  			return &Field_A{arr}
   273  		}
   274  
   275  	case *types.Any:
   276  		return &Field_A{x}
   277  
   278  	case nil: // pass
   279  		return nil
   280  
   281  	default: // value ignored
   282  		return nil
   283  	}
   284  }