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

     1  package ameda
     2  
     3  import (
     4  	"math"
     5  	"strconv"
     6  )
     7  
     8  // Int64ToInterface converts int64 to interface.
     9  func Int64ToInterface(v int64) interface{} {
    10  	return v
    11  }
    12  
    13  // Int64ToInterfacePtr converts int64 to *interface.
    14  func Int64ToInterfacePtr(v int64) *interface{} {
    15  	r := Int64ToInterface(v)
    16  	return &r
    17  }
    18  
    19  // Int64ToString converts int64 to string.
    20  func Int64ToString(v int64) string {
    21  	return strconv.FormatInt(v, 10)
    22  }
    23  
    24  // Int64ToStringPtr converts int64 to *string.
    25  func Int64ToStringPtr(v int64) *string {
    26  	r := Int64ToString(v)
    27  	return &r
    28  }
    29  
    30  // Int64ToBool converts int64 to bool.
    31  func Int64ToBool(v int64) bool {
    32  	return v != 0
    33  }
    34  
    35  // Int64ToBoolPtr converts int64 to *bool.
    36  func Int64ToBoolPtr(v int64) *bool {
    37  	r := Int64ToBool(v)
    38  	return &r
    39  }
    40  
    41  // Int64ToFloat32 converts int64 to float32.
    42  func Int64ToFloat32(v int64) float32 {
    43  	return float32(v)
    44  }
    45  
    46  // Int64ToFloat32Ptr converts int64 to *float32.
    47  func Int64ToFloat32Ptr(v int64) *float32 {
    48  	r := Int64ToFloat32(v)
    49  	return &r
    50  }
    51  
    52  // Int64ToFloat64 converts int64 to float64.
    53  func Int64ToFloat64(v int64) float64 {
    54  	return float64(v)
    55  }
    56  
    57  // Int64ToFloat64Ptr converts int64 to *float64.
    58  func Int64ToFloat64Ptr(v int64) *float64 {
    59  	r := Int64ToFloat64(v)
    60  	return &r
    61  }
    62  
    63  // Int64ToInt converts int64 to int.
    64  func Int64ToInt(v int64) (int, error) {
    65  	if !Host64bit && v > math.MaxInt32 {
    66  		return 0, errOverflowValue
    67  	}
    68  	return int(v), nil
    69  }
    70  
    71  // Int64ToIntPtr converts int64 to *int.
    72  func Int64ToIntPtr(v int64) (*int, error) {
    73  	r, err := Int64ToInt(v)
    74  	return &r, err
    75  }
    76  
    77  // Int64ToInt8 converts int64 to int8.
    78  func Int64ToInt8(v int64) (int8, error) {
    79  	if v > math.MaxInt8 || v < math.MinInt8 {
    80  		return 0, errOverflowValue
    81  	}
    82  	return int8(v), nil
    83  }
    84  
    85  // Int64ToInt8Ptr converts int64 to *int8.
    86  func Int64ToInt8Ptr(v int64) (*int8, error) {
    87  	r, err := Int64ToInt8(v)
    88  	return &r, err
    89  }
    90  
    91  // Int64ToInt16 converts int64 to int16.
    92  func Int64ToInt16(v int64) (int16, error) {
    93  	if v > math.MaxInt16 || v < math.MinInt16 {
    94  		return 0, errOverflowValue
    95  	}
    96  	return int16(v), nil
    97  }
    98  
    99  // Int64ToInt16Ptr converts int64 to *int16.
   100  func Int64ToInt16Ptr(v int64) (*int16, error) {
   101  	r, err := Int64ToInt16(v)
   102  	return &r, err
   103  }
   104  
   105  // Int64ToInt32 converts int64 to int32.
   106  func Int64ToInt32(v int64) (int32, error) {
   107  	if v > math.MaxInt32 || v < math.MinInt32 {
   108  		return 0, errOverflowValue
   109  	}
   110  	return int32(v), nil
   111  }
   112  
   113  // Int64ToInt32Ptr converts int64 to *int32.
   114  func Int64ToInt32Ptr(v int64) (*int32, error) {
   115  	r, err := Int64ToInt32(v)
   116  	return &r, err
   117  }
   118  
   119  // Int64ToInt64Ptr converts int64 to *int64.
   120  func Int64ToInt64Ptr(v int64) *int64 {
   121  	return &v
   122  }
   123  
   124  // Int64ToUint converts int64 to uint.
   125  func Int64ToUint(v int64) (uint, error) {
   126  	if v < 0 {
   127  		return 0, errNegativeValue
   128  	}
   129  	if !Host64bit && v > math.MaxUint32 {
   130  		return 0, errOverflowValue
   131  	}
   132  	return uint(v), nil
   133  }
   134  
   135  // Int64ToUintPtr converts int64 to *uint.
   136  func Int64ToUintPtr(v int64) (*uint, error) {
   137  	r, err := Int64ToUint(v)
   138  	return &r, err
   139  }
   140  
   141  // Int64ToUint8 converts int64 to uint8.
   142  func Int64ToUint8(v int64) (uint8, error) {
   143  	if v < 0 {
   144  		return 0, errNegativeValue
   145  	}
   146  	if v > math.MaxUint8 {
   147  		return 0, errOverflowValue
   148  	}
   149  	return uint8(v), nil
   150  }
   151  
   152  // Int64ToUint8Ptr converts int64 to *uint8.
   153  func Int64ToUint8Ptr(v int64) (*uint8, error) {
   154  	r, err := Int64ToUint8(v)
   155  	return &r, err
   156  }
   157  
   158  // Int64ToUint16 converts int64 to uint16.
   159  func Int64ToUint16(v int64) (uint16, error) {
   160  	if v < 0 {
   161  		return 0, errNegativeValue
   162  	}
   163  	if v > math.MaxUint16 {
   164  		return 0, errOverflowValue
   165  	}
   166  	return uint16(v), nil
   167  }
   168  
   169  // Int64ToUint16Ptr converts int64 to *uint16.
   170  func Int64ToUint16Ptr(v int64) (*uint16, error) {
   171  	r, err := Int64ToUint16(v)
   172  	return &r, err
   173  }
   174  
   175  // Int64ToUint32 converts int64 to uint32.
   176  func Int64ToUint32(v int64) (uint32, error) {
   177  	if v < 0 {
   178  		return 0, errNegativeValue
   179  	}
   180  	return uint32(v), nil
   181  }
   182  
   183  // Int64ToUint32Ptr converts int64 to *uint32.
   184  func Int64ToUint32Ptr(v int64) (*uint32, error) {
   185  	r, err := Int64ToUint32(v)
   186  	return &r, err
   187  }
   188  
   189  // Int64ToUint64 converts int64 to uint64.
   190  func Int64ToUint64(v int64) (uint64, error) {
   191  	if v < 0 {
   192  		return 0, errNegativeValue
   193  	}
   194  	return uint64(v), nil
   195  }
   196  
   197  // Int64ToUint64Ptr converts int64 to *uint64.
   198  func Int64ToUint64Ptr(v int64) (*uint64, error) {
   199  	r, err := Int64ToUint64(v)
   200  	return &r, err
   201  }