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

     1  package ameda
     2  
     3  import (
     4  	"math"
     5  	"strconv"
     6  )
     7  
     8  // MaxUint returns max uint number for current os.
     9  func MaxUint() uint {
    10  	return MaxUnsignedInt
    11  }
    12  
    13  // UintToInterface converts uint to interface.
    14  func UintToInterface(v uint) interface{} {
    15  	return v
    16  }
    17  
    18  // UintToInterfacePtr converts uint to *interface.
    19  func UintToInterfacePtr(v uint) *interface{} {
    20  	r := UintToInterface(v)
    21  	return &r
    22  }
    23  
    24  // UintToString converts uint to string.
    25  func UintToString(v uint) string {
    26  	return strconv.FormatUint(uint64(v), 10)
    27  }
    28  
    29  // UintToStringPtr converts uint to *string.
    30  func UintToStringPtr(v uint) *string {
    31  	r := UintToString(v)
    32  	return &r
    33  }
    34  
    35  // UintToBool converts uint to bool.
    36  func UintToBool(v uint) bool {
    37  	return v != 0
    38  }
    39  
    40  // UintToBoolPtr converts uint to *bool.
    41  func UintToBoolPtr(v uint) *bool {
    42  	r := UintToBool(v)
    43  	return &r
    44  }
    45  
    46  // UintToFloat32 converts uint to float32.
    47  func UintToFloat32(v uint) float32 {
    48  	return float32(v)
    49  }
    50  
    51  // UintToFloat32Ptr converts uint to *float32.
    52  func UintToFloat32Ptr(v uint) *float32 {
    53  	r := UintToFloat32(v)
    54  	return &r
    55  }
    56  
    57  // UintToFloat64 converts uint to float64.
    58  func UintToFloat64(v uint) float64 {
    59  	return float64(v)
    60  }
    61  
    62  // UintToFloat64Ptr converts uint to *float64.
    63  func UintToFloat64Ptr(v uint) *float64 {
    64  	r := UintToFloat64(v)
    65  	return &r
    66  }
    67  
    68  // UintToInt converts uint to int.
    69  func UintToInt(v uint) (int, error) {
    70  	if Host64bit {
    71  		if v > uint(maxInt64) {
    72  			return 0, errOverflowValue
    73  		}
    74  	} else {
    75  		if v > math.MaxInt32 {
    76  			return 0, errOverflowValue
    77  		}
    78  	}
    79  	return int(v), nil
    80  }
    81  
    82  // UintToIntPtr converts uint to *int.
    83  func UintToIntPtr(v uint) (*int, error) {
    84  	r, err := UintToInt(v)
    85  	return &r, err
    86  }
    87  
    88  // UintToInt8 converts uint to int8.
    89  func UintToInt8(v uint) (int8, error) {
    90  	if v > math.MaxInt8 {
    91  		return 0, errOverflowValue
    92  	}
    93  	return int8(v), nil
    94  }
    95  
    96  // UintToInt8Ptr converts uint to *int8.
    97  func UintToInt8Ptr(v uint) (*int8, error) {
    98  	r, err := UintToInt8(v)
    99  	return &r, err
   100  }
   101  
   102  // UintToInt16 converts uint to int16.
   103  func UintToInt16(v uint) (int16, error) {
   104  	if v > math.MaxInt16 {
   105  		return 0, errOverflowValue
   106  	}
   107  	return int16(v), nil
   108  }
   109  
   110  // UintToInt16Ptr converts uint to *int16.
   111  func UintToInt16Ptr(v uint) (*int16, error) {
   112  	r, err := UintToInt16(v)
   113  	return &r, err
   114  }
   115  
   116  // UintToInt32 converts uint to int32.
   117  func UintToInt32(v uint) (int32, error) {
   118  	if v > math.MaxInt32 {
   119  		return 0, errOverflowValue
   120  	}
   121  	return int32(v), nil
   122  }
   123  
   124  // UintToInt32Ptr converts uint to *int32.
   125  func UintToInt32Ptr(v uint) (*int32, error) {
   126  	r, err := UintToInt32(v)
   127  	return &r, err
   128  }
   129  
   130  // UintToInt64 converts uint to int64.
   131  func UintToInt64(v uint) (int64, error) {
   132  	if Host64bit && v > uint(maxInt64) {
   133  		return 0, errOverflowValue
   134  	}
   135  	return int64(v), nil
   136  }
   137  
   138  // UintToInt64Ptr converts uint to *int64.
   139  func UintToInt64Ptr(v uint) (*int64, error) {
   140  	r, err := UintToInt64(v)
   141  	return &r, err
   142  }
   143  
   144  // UintToUintPtr converts uint to *uint.
   145  func UintToUintPtr(v uint) *uint {
   146  	return &v
   147  }
   148  
   149  // UintToUint8 converts uint to uint8.
   150  func UintToUint8(v uint) (uint8, error) {
   151  	if v > math.MaxUint8 {
   152  		return 0, errOverflowValue
   153  	}
   154  	return uint8(v), nil
   155  }
   156  
   157  // UintToUint8Ptr converts uint to *uint8.
   158  func UintToUint8Ptr(v uint) (*uint8, error) {
   159  	r, err := UintToUint8(v)
   160  	return &r, err
   161  }
   162  
   163  // UintToUint16 converts uint to uint16.
   164  func UintToUint16(v uint) (uint16, error) {
   165  	if v > math.MaxUint16 {
   166  		return 0, errOverflowValue
   167  	}
   168  	return uint16(v), nil
   169  }
   170  
   171  // UintToUint16Ptr converts uint to *uint16.
   172  func UintToUint16Ptr(v uint) (*uint16, error) {
   173  	r, err := UintToUint16(v)
   174  	return &r, err
   175  }
   176  
   177  // UintToUint32 converts uint to uint32.
   178  func UintToUint32(v uint) (uint32, error) {
   179  	if Host64bit && v > math.MaxUint32 {
   180  		return 0, errOverflowValue
   181  	}
   182  	return uint32(v), nil
   183  }
   184  
   185  // UintToUint32Ptr converts uint to *uint32.
   186  func UintToUint32Ptr(v uint) (*uint32, error) {
   187  	r, err := UintToUint32(v)
   188  	return &r, err
   189  }
   190  
   191  // UintToUint64 converts uint to uint64.
   192  func UintToUint64(v uint) uint64 {
   193  	return uint64(v)
   194  }
   195  
   196  // UintToUint64Ptr converts uint to *uint64.
   197  func UintToUint64Ptr(v uint) *uint64 {
   198  	r := UintToUint64(v)
   199  	return &r
   200  }