github.com/andeya/ameda@v1.5.3/int.go (about)

     1  package ameda
     2  
     3  import (
     4  	"math"
     5  	"strconv"
     6  )
     7  
     8  // MaxInt returns max int number for current os.
     9  func MaxInt() int {
    10  	return MaxInteger
    11  }
    12  
    13  // IntToInterface converts int to interface.
    14  func IntToInterface(v int) interface{} {
    15  	return v
    16  }
    17  
    18  // IntToInterfacePtr converts int to *interface.
    19  func IntToInterfacePtr(v int) *interface{} {
    20  	r := IntToInterface(v)
    21  	return &r
    22  }
    23  
    24  // IntToString converts int to string.
    25  func IntToString(v int) string {
    26  	return strconv.Itoa(v)
    27  }
    28  
    29  // IntToStringPtr converts int to *string.
    30  func IntToStringPtr(v int) *string {
    31  	r := IntToString(v)
    32  	return &r
    33  }
    34  
    35  // IntToBool converts int to bool.
    36  func IntToBool(v int) bool {
    37  	return v != 0
    38  }
    39  
    40  // IntToBoolPtr converts int to *bool.
    41  func IntToBoolPtr(v int) *bool {
    42  	r := IntToBool(v)
    43  	return &r
    44  }
    45  
    46  // IntToFloat32 converts int to float32.
    47  func IntToFloat32(v int) float32 {
    48  	return float32(v)
    49  }
    50  
    51  // IntToFloat32Ptr converts int to *float32.
    52  func IntToFloat32Ptr(v int) *float32 {
    53  	r := IntToFloat32(v)
    54  	return &r
    55  }
    56  
    57  // IntToFloat64 converts int to float64.
    58  func IntToFloat64(v int) float64 {
    59  	return float64(v)
    60  }
    61  
    62  // IntToFloat64Ptr converts int to *float64.
    63  func IntToFloat64Ptr(v int) *float64 {
    64  	r := IntToFloat64(v)
    65  	return &r
    66  }
    67  
    68  // IntToIntPtr converts int to *int.
    69  func IntToIntPtr(v int) *int {
    70  	return &v
    71  }
    72  
    73  // IntToInt8 converts int to int8.
    74  func IntToInt8(v int) (int8, error) {
    75  	if v > math.MaxInt8 || v < math.MinInt8 {
    76  		return 0, errOverflowValue
    77  	}
    78  	return int8(v), nil
    79  }
    80  
    81  // IntToInt8Ptr converts int to *int8.
    82  func IntToInt8Ptr(v int) (*int8, error) {
    83  	r, err := IntToInt8(v)
    84  	return &r, err
    85  }
    86  
    87  // IntToInt16 converts int to int16.
    88  func IntToInt16(v int) (int16, error) {
    89  	if v > math.MaxInt16 || v < math.MinInt16 {
    90  		return 0, errOverflowValue
    91  	}
    92  	return int16(v), nil
    93  }
    94  
    95  // IntToInt16Ptr converts int to *int16.
    96  func IntToInt16Ptr(v int) (*int16, error) {
    97  	r, err := IntToInt16(v)
    98  	return &r, err
    99  }
   100  
   101  // IntToInt32 converts int to int32.
   102  func IntToInt32(v int) (int32, error) {
   103  	if Host64bit && (v > math.MaxInt32 || v < math.MinInt32) {
   104  		return 0, errOverflowValue
   105  	}
   106  	return int32(v), nil
   107  }
   108  
   109  // IntToInt32Ptr converts int to *int32.
   110  func IntToInt32Ptr(v int) (*int32, error) {
   111  	r, err := IntToInt32(v)
   112  	return &r, err
   113  }
   114  
   115  // IntToInt64 converts int to int64.
   116  func IntToInt64(v int) int64 {
   117  	return int64(v)
   118  }
   119  
   120  // IntToInt64Ptr converts int to *int64.
   121  func IntToInt64Ptr(v int) *int64 {
   122  	r := IntToInt64(v)
   123  	return &r
   124  }
   125  
   126  // IntToUint converts int to uint.
   127  func IntToUint(v int) (uint, error) {
   128  	if v < 0 {
   129  		return 0, errNegativeValue
   130  	}
   131  	return uint(v), nil
   132  }
   133  
   134  // IntToUintPtr converts int to *uint.
   135  func IntToUintPtr(v int) (*uint, error) {
   136  	r, err := IntToUint(v)
   137  	return &r, err
   138  }
   139  
   140  // IntToUint8 converts int to uint8.
   141  func IntToUint8(v int) (uint8, error) {
   142  	if v < 0 {
   143  		return 0, errNegativeValue
   144  	}
   145  	if v > math.MaxUint8 {
   146  		return 0, errOverflowValue
   147  	}
   148  	return uint8(v), nil
   149  }
   150  
   151  // IntToUint8Ptr converts int to *uint8.
   152  func IntToUint8Ptr(v int) (*uint8, error) {
   153  	r, err := IntToUint8(v)
   154  	return &r, err
   155  }
   156  
   157  // IntToUint16 converts int to uint16.
   158  func IntToUint16(v int) (uint16, error) {
   159  	if v < 0 {
   160  		return 0, errNegativeValue
   161  	}
   162  	if v > math.MaxUint16 {
   163  		return 0, errOverflowValue
   164  	}
   165  	return uint16(v), nil
   166  }
   167  
   168  // IntToUint16Ptr converts int to *uint16.
   169  func IntToUint16Ptr(v int) (*uint16, error) {
   170  	r, err := IntToUint16(v)
   171  	return &r, err
   172  }
   173  
   174  // IntToUint32 converts int to uint32.
   175  func IntToUint32(v int) (uint32, error) {
   176  	if v < 0 {
   177  		return 0, errNegativeValue
   178  	}
   179  	if Host64bit && v > int(maxUint32) {
   180  		return 0, errOverflowValue
   181  	}
   182  	return uint32(v), nil
   183  }
   184  
   185  // IntToUint32Ptr converts int to *uint32.
   186  func IntToUint32Ptr(v int) (*uint32, error) {
   187  	r, err := IntToUint32(v)
   188  	return &r, err
   189  }
   190  
   191  // IntToUint64 converts int to uint64.
   192  func IntToUint64(v int) (uint64, error) {
   193  	if v < 0 {
   194  		return 0, errNegativeValue
   195  	}
   196  	return uint64(v), nil
   197  }
   198  
   199  // IntToUint64Ptr converts int to *uint64.
   200  func IntToUint64Ptr(v int) (*uint64, error) {
   201  	r, err := IntToUint64(v)
   202  	return &r, err
   203  }