github.com/alibabacloud-go/tea@v1.3.10/tea/trans.go (about)

     1  package tea
     2  
     3  func String(a string) *string {
     4  	return &a
     5  }
     6  
     7  func StringValue(a *string) string {
     8  	if a == nil {
     9  		return ""
    10  	}
    11  	return *a
    12  }
    13  
    14  func Int(a int) *int {
    15  	return &a
    16  }
    17  
    18  func IntValue(a *int) int {
    19  	if a == nil {
    20  		return 0
    21  	}
    22  	return *a
    23  }
    24  
    25  func Int8(a int8) *int8 {
    26  	return &a
    27  }
    28  
    29  func Int8Value(a *int8) int8 {
    30  	if a == nil {
    31  		return 0
    32  	}
    33  	return *a
    34  }
    35  
    36  func Int16(a int16) *int16 {
    37  	return &a
    38  }
    39  
    40  func Int16Value(a *int16) int16 {
    41  	if a == nil {
    42  		return 0
    43  	}
    44  	return *a
    45  }
    46  
    47  func Int32(a int32) *int32 {
    48  	return &a
    49  }
    50  
    51  func Int32Value(a *int32) int32 {
    52  	if a == nil {
    53  		return 0
    54  	}
    55  	return *a
    56  }
    57  
    58  func Int64(a int64) *int64 {
    59  	return &a
    60  }
    61  
    62  func Int64Value(a *int64) int64 {
    63  	if a == nil {
    64  		return 0
    65  	}
    66  	return *a
    67  }
    68  
    69  func Bool(a bool) *bool {
    70  	return &a
    71  }
    72  
    73  func BoolValue(a *bool) bool {
    74  	if a == nil {
    75  		return false
    76  	}
    77  	return *a
    78  }
    79  
    80  func Uint(a uint) *uint {
    81  	return &a
    82  }
    83  
    84  func UintValue(a *uint) uint {
    85  	if a == nil {
    86  		return 0
    87  	}
    88  	return *a
    89  }
    90  
    91  func Uint8(a uint8) *uint8 {
    92  	return &a
    93  }
    94  
    95  func Uint8Value(a *uint8) uint8 {
    96  	if a == nil {
    97  		return 0
    98  	}
    99  	return *a
   100  }
   101  
   102  func Uint16(a uint16) *uint16 {
   103  	return &a
   104  }
   105  
   106  func Uint16Value(a *uint16) uint16 {
   107  	if a == nil {
   108  		return 0
   109  	}
   110  	return *a
   111  }
   112  
   113  func Uint32(a uint32) *uint32 {
   114  	return &a
   115  }
   116  
   117  func Uint32Value(a *uint32) uint32 {
   118  	if a == nil {
   119  		return 0
   120  	}
   121  	return *a
   122  }
   123  
   124  func Uint64(a uint64) *uint64 {
   125  	return &a
   126  }
   127  
   128  func Uint64Value(a *uint64) uint64 {
   129  	if a == nil {
   130  		return 0
   131  	}
   132  	return *a
   133  }
   134  
   135  func Float32(a float32) *float32 {
   136  	return &a
   137  }
   138  
   139  func Float32Value(a *float32) float32 {
   140  	if a == nil {
   141  		return 0
   142  	}
   143  	return *a
   144  }
   145  
   146  func Float64(a float64) *float64 {
   147  	return &a
   148  }
   149  
   150  func Float64Value(a *float64) float64 {
   151  	if a == nil {
   152  		return 0
   153  	}
   154  	return *a
   155  }
   156  
   157  func IntSlice(a []int) []*int {
   158  	if a == nil {
   159  		return nil
   160  	}
   161  	res := make([]*int, len(a))
   162  	for i := 0; i < len(a); i++ {
   163  		res[i] = &a[i]
   164  	}
   165  	return res
   166  }
   167  
   168  func IntValueSlice(a []*int) []int {
   169  	if a == nil {
   170  		return nil
   171  	}
   172  	res := make([]int, len(a))
   173  	for i := 0; i < len(a); i++ {
   174  		if a[i] != nil {
   175  			res[i] = *a[i]
   176  		}
   177  	}
   178  	return res
   179  }
   180  
   181  func Int8Slice(a []int8) []*int8 {
   182  	if a == nil {
   183  		return nil
   184  	}
   185  	res := make([]*int8, len(a))
   186  	for i := 0; i < len(a); i++ {
   187  		res[i] = &a[i]
   188  	}
   189  	return res
   190  }
   191  
   192  func Int8ValueSlice(a []*int8) []int8 {
   193  	if a == nil {
   194  		return nil
   195  	}
   196  	res := make([]int8, len(a))
   197  	for i := 0; i < len(a); i++ {
   198  		if a[i] != nil {
   199  			res[i] = *a[i]
   200  		}
   201  	}
   202  	return res
   203  }
   204  
   205  func Int16Slice(a []int16) []*int16 {
   206  	if a == nil {
   207  		return nil
   208  	}
   209  	res := make([]*int16, len(a))
   210  	for i := 0; i < len(a); i++ {
   211  		res[i] = &a[i]
   212  	}
   213  	return res
   214  }
   215  
   216  func Int16ValueSlice(a []*int16) []int16 {
   217  	if a == nil {
   218  		return nil
   219  	}
   220  	res := make([]int16, len(a))
   221  	for i := 0; i < len(a); i++ {
   222  		if a[i] != nil {
   223  			res[i] = *a[i]
   224  		}
   225  	}
   226  	return res
   227  }
   228  
   229  func Int32Slice(a []int32) []*int32 {
   230  	if a == nil {
   231  		return nil
   232  	}
   233  	res := make([]*int32, len(a))
   234  	for i := 0; i < len(a); i++ {
   235  		res[i] = &a[i]
   236  	}
   237  	return res
   238  }
   239  
   240  func Int32ValueSlice(a []*int32) []int32 {
   241  	if a == nil {
   242  		return nil
   243  	}
   244  	res := make([]int32, len(a))
   245  	for i := 0; i < len(a); i++ {
   246  		if a[i] != nil {
   247  			res[i] = *a[i]
   248  		}
   249  	}
   250  	return res
   251  }
   252  
   253  func Int64Slice(a []int64) []*int64 {
   254  	if a == nil {
   255  		return nil
   256  	}
   257  	res := make([]*int64, len(a))
   258  	for i := 0; i < len(a); i++ {
   259  		res[i] = &a[i]
   260  	}
   261  	return res
   262  }
   263  
   264  func Int64ValueSlice(a []*int64) []int64 {
   265  	if a == nil {
   266  		return nil
   267  	}
   268  	res := make([]int64, len(a))
   269  	for i := 0; i < len(a); i++ {
   270  		if a[i] != nil {
   271  			res[i] = *a[i]
   272  		}
   273  	}
   274  	return res
   275  }
   276  
   277  func UintSlice(a []uint) []*uint {
   278  	if a == nil {
   279  		return nil
   280  	}
   281  	res := make([]*uint, len(a))
   282  	for i := 0; i < len(a); i++ {
   283  		res[i] = &a[i]
   284  	}
   285  	return res
   286  }
   287  
   288  func UintValueSlice(a []*uint) []uint {
   289  	if a == nil {
   290  		return nil
   291  	}
   292  	res := make([]uint, len(a))
   293  	for i := 0; i < len(a); i++ {
   294  		if a[i] != nil {
   295  			res[i] = *a[i]
   296  		}
   297  	}
   298  	return res
   299  }
   300  
   301  func Uint8Slice(a []uint8) []*uint8 {
   302  	if a == nil {
   303  		return nil
   304  	}
   305  	res := make([]*uint8, len(a))
   306  	for i := 0; i < len(a); i++ {
   307  		res[i] = &a[i]
   308  	}
   309  	return res
   310  }
   311  
   312  func Uint8ValueSlice(a []*uint8) []uint8 {
   313  	if a == nil {
   314  		return nil
   315  	}
   316  	res := make([]uint8, len(a))
   317  	for i := 0; i < len(a); i++ {
   318  		if a[i] != nil {
   319  			res[i] = *a[i]
   320  		}
   321  	}
   322  	return res
   323  }
   324  
   325  func Uint16Slice(a []uint16) []*uint16 {
   326  	if a == nil {
   327  		return nil
   328  	}
   329  	res := make([]*uint16, len(a))
   330  	for i := 0; i < len(a); i++ {
   331  		res[i] = &a[i]
   332  	}
   333  	return res
   334  }
   335  
   336  func Uint16ValueSlice(a []*uint16) []uint16 {
   337  	if a == nil {
   338  		return nil
   339  	}
   340  	res := make([]uint16, len(a))
   341  	for i := 0; i < len(a); i++ {
   342  		if a[i] != nil {
   343  			res[i] = *a[i]
   344  		}
   345  	}
   346  	return res
   347  }
   348  
   349  func Uint32Slice(a []uint32) []*uint32 {
   350  	if a == nil {
   351  		return nil
   352  	}
   353  	res := make([]*uint32, len(a))
   354  	for i := 0; i < len(a); i++ {
   355  		res[i] = &a[i]
   356  	}
   357  	return res
   358  }
   359  
   360  func Uint32ValueSlice(a []*uint32) []uint32 {
   361  	if a == nil {
   362  		return nil
   363  	}
   364  	res := make([]uint32, len(a))
   365  	for i := 0; i < len(a); i++ {
   366  		if a[i] != nil {
   367  			res[i] = *a[i]
   368  		}
   369  	}
   370  	return res
   371  }
   372  
   373  func Uint64Slice(a []uint64) []*uint64 {
   374  	if a == nil {
   375  		return nil
   376  	}
   377  	res := make([]*uint64, len(a))
   378  	for i := 0; i < len(a); i++ {
   379  		res[i] = &a[i]
   380  	}
   381  	return res
   382  }
   383  
   384  func Uint64ValueSlice(a []*uint64) []uint64 {
   385  	if a == nil {
   386  		return nil
   387  	}
   388  	res := make([]uint64, len(a))
   389  	for i := 0; i < len(a); i++ {
   390  		if a[i] != nil {
   391  			res[i] = *a[i]
   392  		}
   393  	}
   394  	return res
   395  }
   396  
   397  func Float32Slice(a []float32) []*float32 {
   398  	if a == nil {
   399  		return nil
   400  	}
   401  	res := make([]*float32, len(a))
   402  	for i := 0; i < len(a); i++ {
   403  		res[i] = &a[i]
   404  	}
   405  	return res
   406  }
   407  
   408  func Float32ValueSlice(a []*float32) []float32 {
   409  	if a == nil {
   410  		return nil
   411  	}
   412  	res := make([]float32, len(a))
   413  	for i := 0; i < len(a); i++ {
   414  		if a[i] != nil {
   415  			res[i] = *a[i]
   416  		}
   417  	}
   418  	return res
   419  }
   420  
   421  func Float64Slice(a []float64) []*float64 {
   422  	if a == nil {
   423  		return nil
   424  	}
   425  	res := make([]*float64, len(a))
   426  	for i := 0; i < len(a); i++ {
   427  		res[i] = &a[i]
   428  	}
   429  	return res
   430  }
   431  
   432  func Float64ValueSlice(a []*float64) []float64 {
   433  	if a == nil {
   434  		return nil
   435  	}
   436  	res := make([]float64, len(a))
   437  	for i := 0; i < len(a); i++ {
   438  		if a[i] != nil {
   439  			res[i] = *a[i]
   440  		}
   441  	}
   442  	return res
   443  }
   444  
   445  func StringSlice(a []string) []*string {
   446  	if a == nil {
   447  		return nil
   448  	}
   449  	res := make([]*string, len(a))
   450  	for i := 0; i < len(a); i++ {
   451  		res[i] = &a[i]
   452  	}
   453  	return res
   454  }
   455  
   456  func StringSliceValue(a []*string) []string {
   457  	if a == nil {
   458  		return nil
   459  	}
   460  	res := make([]string, len(a))
   461  	for i := 0; i < len(a); i++ {
   462  		if a[i] != nil {
   463  			res[i] = *a[i]
   464  		}
   465  	}
   466  	return res
   467  }
   468  
   469  func BoolSlice(a []bool) []*bool {
   470  	if a == nil {
   471  		return nil
   472  	}
   473  	res := make([]*bool, len(a))
   474  	for i := 0; i < len(a); i++ {
   475  		res[i] = &a[i]
   476  	}
   477  	return res
   478  }
   479  
   480  func BoolSliceValue(a []*bool) []bool {
   481  	if a == nil {
   482  		return nil
   483  	}
   484  	res := make([]bool, len(a))
   485  	for i := 0; i < len(a); i++ {
   486  		if a[i] != nil {
   487  			res[i] = *a[i]
   488  		}
   489  	}
   490  	return res
   491  }