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

     1  package ameda
     2  
     3  import (
     4  	"math"
     5  	"strconv"
     6  )
     7  
     8  // Uint64ToInterface converts uint64 to interface.
     9  func Uint64ToInterface(v uint64) interface{} {
    10  	return v
    11  }
    12  
    13  // Uint64ToInterfacePtr converts uint64 to *interface.
    14  func Uint64ToInterfacePtr(v uint64) *interface{} {
    15  	r := Uint64ToInterface(v)
    16  	return &r
    17  }
    18  
    19  // Uint64ToString converts uint64 to string.
    20  func Uint64ToString(v uint64) string {
    21  	return strconv.FormatUint(uint64(v), 10)
    22  }
    23  
    24  // Uint64ToStringPtr converts uint64 to *string.
    25  func Uint64ToStringPtr(v uint64) *string {
    26  	r := Uint64ToString(v)
    27  	return &r
    28  }
    29  
    30  // Uint64ToBool converts uint64 to bool.
    31  func Uint64ToBool(v uint64) bool {
    32  	return v != 0
    33  }
    34  
    35  // Uint64ToBoolPtr converts uint64 to *bool.
    36  func Uint64ToBoolPtr(v uint64) *bool {
    37  	r := Uint64ToBool(v)
    38  	return &r
    39  }
    40  
    41  // Uint64ToFloat32 converts uint64 to float32.
    42  func Uint64ToFloat32(v uint64) float32 {
    43  	return float32(v)
    44  }
    45  
    46  // Uint64ToFloat32Ptr converts uint64 to *float32.
    47  func Uint64ToFloat32Ptr(v uint64) *float32 {
    48  	r := Uint64ToFloat32(v)
    49  	return &r
    50  }
    51  
    52  // Uint64ToFloat64 converts uint64 to float64.
    53  func Uint64ToFloat64(v uint64) float64 {
    54  	return float64(v)
    55  }
    56  
    57  // Uint64ToFloat64Ptr converts uint64 to *float64.
    58  func Uint64ToFloat64Ptr(v uint64) *float64 {
    59  	r := Uint64ToFloat64(v)
    60  	return &r
    61  }
    62  
    63  // Uint64ToInt converts uint64 to int.
    64  func Uint64ToInt(v uint64) int {
    65  	return int(v)
    66  }
    67  
    68  // Uint64ToIntPtr converts uint64 to *int.
    69  func Uint64ToIntPtr(v uint64) *int {
    70  	r := Uint64ToInt(v)
    71  	return &r
    72  }
    73  
    74  // Uint64ToInt8 converts uint64 to int8.
    75  func Uint64ToInt8(v uint64) (int8, error) {
    76  	if v > math.MaxInt8 {
    77  		return 0, errOverflowValue
    78  	}
    79  	return int8(v), nil
    80  }
    81  
    82  // Uint64ToInt8Ptr converts uint64 to *int8.
    83  func Uint64ToInt8Ptr(v uint64) (*int8, error) {
    84  	r, err := Uint64ToInt8(v)
    85  	return &r, err
    86  }
    87  
    88  // Uint64ToInt16 converts uint64 to int16.
    89  func Uint64ToInt16(v uint64) (int16, error) {
    90  	if v > math.MaxInt16 {
    91  		return 0, errOverflowValue
    92  	}
    93  	return int16(v), nil
    94  }
    95  
    96  // Uint64ToInt16Ptr converts uint64 to *int16.
    97  func Uint64ToInt16Ptr(v uint64) (*int16, error) {
    98  	r, err := Uint64ToInt16(v)
    99  	return &r, err
   100  }
   101  
   102  // Uint64ToInt32 converts uint64 to int32.
   103  func Uint64ToInt32(v uint64) (int32, error) {
   104  	if v > math.MaxInt32 {
   105  		return 0, errOverflowValue
   106  	}
   107  	return int32(v), nil
   108  }
   109  
   110  // Uint64ToInt32Ptr converts uint64 to *int32.
   111  func Uint64ToInt32Ptr(v uint64) (*int32, error) {
   112  	r, err := Uint64ToInt32(v)
   113  	return &r, err
   114  }
   115  
   116  // Uint64ToInt64 converts uint64 to int64.
   117  func Uint64ToInt64(v uint64) (int64, error) {
   118  	if v > math.MaxInt64 {
   119  		return 0, errOverflowValue
   120  	}
   121  	return int64(v), nil
   122  }
   123  
   124  // Uint64ToInt64Ptr converts uint64 to *int64.
   125  func Uint64ToInt64Ptr(v uint64) (*int64, error) {
   126  	r, err := Uint64ToInt64(v)
   127  	return &r, err
   128  }
   129  
   130  // Uint64ToUint converts uint64 to uint.
   131  func Uint64ToUint(v uint64) (uint, error) {
   132  	if !Host64bit && v > math.MaxUint32 {
   133  		return 0, errOverflowValue
   134  	}
   135  	return uint(v), nil
   136  }
   137  
   138  // Uint64ToUintPtr converts uint64 to *uint.
   139  func Uint64ToUintPtr(v uint64) (*uint, error) {
   140  	r, err := Uint64ToUint(v)
   141  	return &r, err
   142  }
   143  
   144  // Uint64ToUint8 converts uint64 to uint8.
   145  func Uint64ToUint8(v uint64) (uint8, error) {
   146  	if v > math.MaxUint8 {
   147  		return 0, errOverflowValue
   148  	}
   149  	return uint8(v), nil
   150  }
   151  
   152  // Uint64ToUint8Ptr converts uint64 to *uint8.
   153  func Uint64ToUint8Ptr(v uint64) (*uint8, error) {
   154  	r, err := Uint64ToUint8(v)
   155  	return &r, err
   156  }
   157  
   158  // Uint64ToUint16 converts uint64 to uint16.
   159  func Uint64ToUint16(v uint64) (uint16, error) {
   160  	if v > math.MaxUint16 {
   161  		return 0, errOverflowValue
   162  	}
   163  	return uint16(v), nil
   164  }
   165  
   166  // Uint64ToUint16Ptr converts uint64 to *uint16.
   167  func Uint64ToUint16Ptr(v uint64) (*uint16, error) {
   168  	r, err := Uint64ToUint16(v)
   169  	return &r, err
   170  }
   171  
   172  // Uint64ToUint32 converts uint64 to uint32.
   173  func Uint64ToUint32(v uint64) (uint32, error) {
   174  	if v > math.MaxUint32 {
   175  		return 0, errOverflowValue
   176  	}
   177  	return uint32(v), nil
   178  }
   179  
   180  // Uint64ToUint32Ptr converts uint64 to *uint32.
   181  func Uint64ToUint32Ptr(v uint64) (*uint32, error) {
   182  	r, err := Uint64ToUint32(v)
   183  	return &r, err
   184  }
   185  
   186  // Uint64ToUint64Ptr converts uint64 to *uint64.
   187  func Uint64ToUint64Ptr(v uint64) *uint64 {
   188  	return &v
   189  }