github.com/gogf/gf@v1.16.9/util/gconv/gconv_slice_uint.go (about)

     1  // Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
     2  //
     3  // This Source Code Form is subject to the terms of the MIT License.
     4  // If a copy of the MIT was not distributed with this file,
     5  // You can obtain one at https://github.com/gogf/gf.
     6  
     7  package gconv
     8  
     9  import "reflect"
    10  
    11  // SliceUint is alias of Uints.
    12  func SliceUint(any interface{}) []uint {
    13  	return Uints(any)
    14  }
    15  
    16  // SliceUint32 is alias of Uint32s.
    17  func SliceUint32(any interface{}) []uint32 {
    18  	return Uint32s(any)
    19  }
    20  
    21  // SliceUint64 is alias of Uint64s.
    22  func SliceUint64(any interface{}) []uint64 {
    23  	return Uint64s(any)
    24  }
    25  
    26  // Uints converts `any` to []uint.
    27  func Uints(any interface{}) []uint {
    28  	if any == nil {
    29  		return nil
    30  	}
    31  
    32  	var array []uint
    33  	switch value := any.(type) {
    34  	case string:
    35  		if value == "" {
    36  			return []uint{}
    37  		}
    38  		return []uint{Uint(value)}
    39  	case []string:
    40  		array = make([]uint, len(value))
    41  		for k, v := range value {
    42  			array[k] = Uint(v)
    43  		}
    44  	case []int8:
    45  		array = make([]uint, len(value))
    46  		for k, v := range value {
    47  			array[k] = uint(v)
    48  		}
    49  	case []int16:
    50  		array = make([]uint, len(value))
    51  		for k, v := range value {
    52  			array[k] = uint(v)
    53  		}
    54  	case []int32:
    55  		array = make([]uint, len(value))
    56  		for k, v := range value {
    57  			array[k] = uint(v)
    58  		}
    59  	case []int64:
    60  		array = make([]uint, len(value))
    61  		for k, v := range value {
    62  			array[k] = uint(v)
    63  		}
    64  	case []uint:
    65  		array = value
    66  	case []uint8:
    67  		array = make([]uint, len(value))
    68  		for k, v := range value {
    69  			array[k] = uint(v)
    70  		}
    71  	case []uint16:
    72  		array = make([]uint, len(value))
    73  		for k, v := range value {
    74  			array[k] = uint(v)
    75  		}
    76  	case []uint32:
    77  		array = make([]uint, len(value))
    78  		for k, v := range value {
    79  			array[k] = uint(v)
    80  		}
    81  	case []uint64:
    82  		array = make([]uint, len(value))
    83  		for k, v := range value {
    84  			array[k] = uint(v)
    85  		}
    86  	case []bool:
    87  		array = make([]uint, len(value))
    88  		for k, v := range value {
    89  			if v {
    90  				array[k] = 1
    91  			} else {
    92  				array[k] = 0
    93  			}
    94  		}
    95  	case []float32:
    96  		array = make([]uint, len(value))
    97  		for k, v := range value {
    98  			array[k] = Uint(v)
    99  		}
   100  	case []float64:
   101  		array = make([]uint, len(value))
   102  		for k, v := range value {
   103  			array[k] = Uint(v)
   104  		}
   105  	case []interface{}:
   106  		array = make([]uint, len(value))
   107  		for k, v := range value {
   108  			array[k] = Uint(v)
   109  		}
   110  	case [][]byte:
   111  		array = make([]uint, len(value))
   112  		for k, v := range value {
   113  			array[k] = Uint(v)
   114  		}
   115  	default:
   116  		if v, ok := any.(apiUints); ok {
   117  			return v.Uints()
   118  		}
   119  		if v, ok := any.(apiInterfaces); ok {
   120  			return Uints(v.Interfaces())
   121  		}
   122  		// Not a common type, it then uses reflection for conversion.
   123  		var reflectValue reflect.Value
   124  		if v, ok := value.(reflect.Value); ok {
   125  			reflectValue = v
   126  		} else {
   127  			reflectValue = reflect.ValueOf(value)
   128  		}
   129  		reflectKind := reflectValue.Kind()
   130  		for reflectKind == reflect.Ptr {
   131  			reflectValue = reflectValue.Elem()
   132  			reflectKind = reflectValue.Kind()
   133  		}
   134  		switch reflectKind {
   135  		case reflect.Slice, reflect.Array:
   136  			var (
   137  				length = reflectValue.Len()
   138  				slice  = make([]uint, length)
   139  			)
   140  			for i := 0; i < length; i++ {
   141  				slice[i] = Uint(reflectValue.Index(i).Interface())
   142  			}
   143  			return slice
   144  
   145  		default:
   146  			return []uint{Uint(any)}
   147  		}
   148  	}
   149  	return array
   150  }
   151  
   152  // Uint32s converts `any` to []uint32.
   153  func Uint32s(any interface{}) []uint32 {
   154  	if any == nil {
   155  		return nil
   156  	}
   157  	var array []uint32
   158  	switch value := any.(type) {
   159  	case string:
   160  		if value == "" {
   161  			return []uint32{}
   162  		}
   163  		return []uint32{Uint32(value)}
   164  	case []string:
   165  		array = make([]uint32, len(value))
   166  		for k, v := range value {
   167  			array[k] = Uint32(v)
   168  		}
   169  	case []int8:
   170  		array = make([]uint32, len(value))
   171  		for k, v := range value {
   172  			array[k] = uint32(v)
   173  		}
   174  	case []int16:
   175  		array = make([]uint32, len(value))
   176  		for k, v := range value {
   177  			array[k] = uint32(v)
   178  		}
   179  	case []int32:
   180  		array = make([]uint32, len(value))
   181  		for k, v := range value {
   182  			array[k] = uint32(v)
   183  		}
   184  	case []int64:
   185  		array = make([]uint32, len(value))
   186  		for k, v := range value {
   187  			array[k] = uint32(v)
   188  		}
   189  	case []uint:
   190  		array = make([]uint32, len(value))
   191  		for k, v := range value {
   192  			array[k] = uint32(v)
   193  		}
   194  	case []uint8:
   195  		array = make([]uint32, len(value))
   196  		for k, v := range value {
   197  			array[k] = uint32(v)
   198  		}
   199  	case []uint16:
   200  		array = make([]uint32, len(value))
   201  		for k, v := range value {
   202  			array[k] = uint32(v)
   203  		}
   204  	case []uint32:
   205  		array = value
   206  	case []uint64:
   207  		array = make([]uint32, len(value))
   208  		for k, v := range value {
   209  			array[k] = uint32(v)
   210  		}
   211  	case []bool:
   212  		array = make([]uint32, len(value))
   213  		for k, v := range value {
   214  			if v {
   215  				array[k] = 1
   216  			} else {
   217  				array[k] = 0
   218  			}
   219  		}
   220  	case []float32:
   221  		array = make([]uint32, len(value))
   222  		for k, v := range value {
   223  			array[k] = Uint32(v)
   224  		}
   225  	case []float64:
   226  		array = make([]uint32, len(value))
   227  		for k, v := range value {
   228  			array[k] = Uint32(v)
   229  		}
   230  	case []interface{}:
   231  		array = make([]uint32, len(value))
   232  		for k, v := range value {
   233  			array[k] = Uint32(v)
   234  		}
   235  	case [][]byte:
   236  		array = make([]uint32, len(value))
   237  		for k, v := range value {
   238  			array[k] = Uint32(v)
   239  		}
   240  	default:
   241  		if v, ok := any.(apiUints); ok {
   242  			return Uint32s(v.Uints())
   243  		}
   244  		if v, ok := any.(apiInterfaces); ok {
   245  			return Uint32s(v.Interfaces())
   246  		}
   247  		// Not a common type, it then uses reflection for conversion.
   248  		var reflectValue reflect.Value
   249  		if v, ok := value.(reflect.Value); ok {
   250  			reflectValue = v
   251  		} else {
   252  			reflectValue = reflect.ValueOf(value)
   253  		}
   254  		reflectKind := reflectValue.Kind()
   255  		for reflectKind == reflect.Ptr {
   256  			reflectValue = reflectValue.Elem()
   257  			reflectKind = reflectValue.Kind()
   258  		}
   259  		switch reflectKind {
   260  		case reflect.Slice, reflect.Array:
   261  			var (
   262  				length = reflectValue.Len()
   263  				slice  = make([]uint32, length)
   264  			)
   265  			for i := 0; i < length; i++ {
   266  				slice[i] = Uint32(reflectValue.Index(i).Interface())
   267  			}
   268  			return slice
   269  
   270  		default:
   271  			return []uint32{Uint32(any)}
   272  		}
   273  	}
   274  	return array
   275  }
   276  
   277  // Uint64s converts `any` to []uint64.
   278  func Uint64s(any interface{}) []uint64 {
   279  	if any == nil {
   280  		return nil
   281  	}
   282  	var array []uint64
   283  	switch value := any.(type) {
   284  	case string:
   285  		if value == "" {
   286  			return []uint64{}
   287  		}
   288  		return []uint64{Uint64(value)}
   289  	case []string:
   290  		array = make([]uint64, len(value))
   291  		for k, v := range value {
   292  			array[k] = Uint64(v)
   293  		}
   294  	case []int8:
   295  		array = make([]uint64, len(value))
   296  		for k, v := range value {
   297  			array[k] = uint64(v)
   298  		}
   299  	case []int16:
   300  		array = make([]uint64, len(value))
   301  		for k, v := range value {
   302  			array[k] = uint64(v)
   303  		}
   304  	case []int32:
   305  		array = make([]uint64, len(value))
   306  		for k, v := range value {
   307  			array[k] = uint64(v)
   308  		}
   309  	case []int64:
   310  		array = make([]uint64, len(value))
   311  		for k, v := range value {
   312  			array[k] = uint64(v)
   313  		}
   314  	case []uint:
   315  		array = make([]uint64, len(value))
   316  		for k, v := range value {
   317  			array[k] = uint64(v)
   318  		}
   319  	case []uint8:
   320  		array = make([]uint64, len(value))
   321  		for k, v := range value {
   322  			array[k] = uint64(v)
   323  		}
   324  	case []uint16:
   325  		array = make([]uint64, len(value))
   326  		for k, v := range value {
   327  			array[k] = uint64(v)
   328  		}
   329  	case []uint32:
   330  		array = make([]uint64, len(value))
   331  		for k, v := range value {
   332  			array[k] = uint64(v)
   333  		}
   334  	case []uint64:
   335  		array = value
   336  	case []bool:
   337  		array = make([]uint64, len(value))
   338  		for k, v := range value {
   339  			if v {
   340  				array[k] = 1
   341  			} else {
   342  				array[k] = 0
   343  			}
   344  		}
   345  	case []float32:
   346  		array = make([]uint64, len(value))
   347  		for k, v := range value {
   348  			array[k] = Uint64(v)
   349  		}
   350  	case []float64:
   351  		array = make([]uint64, len(value))
   352  		for k, v := range value {
   353  			array[k] = Uint64(v)
   354  		}
   355  	case []interface{}:
   356  		array = make([]uint64, len(value))
   357  		for k, v := range value {
   358  			array[k] = Uint64(v)
   359  		}
   360  	case [][]byte:
   361  		array = make([]uint64, len(value))
   362  		for k, v := range value {
   363  			array[k] = Uint64(v)
   364  		}
   365  	default:
   366  		if v, ok := any.(apiUints); ok {
   367  			return Uint64s(v.Uints())
   368  		}
   369  		if v, ok := any.(apiInterfaces); ok {
   370  			return Uint64s(v.Interfaces())
   371  		}
   372  		// Not a common type, it then uses reflection for conversion.
   373  		var reflectValue reflect.Value
   374  		if v, ok := value.(reflect.Value); ok {
   375  			reflectValue = v
   376  		} else {
   377  			reflectValue = reflect.ValueOf(value)
   378  		}
   379  		reflectKind := reflectValue.Kind()
   380  		for reflectKind == reflect.Ptr {
   381  			reflectValue = reflectValue.Elem()
   382  			reflectKind = reflectValue.Kind()
   383  		}
   384  		switch reflectKind {
   385  		case reflect.Slice, reflect.Array:
   386  			var (
   387  				length = reflectValue.Len()
   388  				slice  = make([]uint64, length)
   389  			)
   390  			for i := 0; i < length; i++ {
   391  				slice[i] = Uint64(reflectValue.Index(i).Interface())
   392  			}
   393  			return slice
   394  
   395  		default:
   396  			return []uint64{Uint64(any)}
   397  		}
   398  	}
   399  	return array
   400  }