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