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

     1  package ameda
     2  
     3  import (
     4  	"math"
     5  	"strconv"
     6  )
     7  
     8  // Uint32ToInterface converts uint32 to interface.
     9  func Uint32ToInterface(v uint32) interface{} {
    10  	return v
    11  }
    12  
    13  // Uint32ToInterfacePtr converts uint32 to *interface.
    14  func Uint32ToInterfacePtr(v uint32) *interface{} {
    15  	r := Uint32ToInterface(v)
    16  	return &r
    17  }
    18  
    19  // Uint32ToString converts uint32 to string.
    20  func Uint32ToString(v uint32) string {
    21  	return strconv.FormatUint(uint64(v), 10)
    22  }
    23  
    24  // Uint32ToStringPtr converts uint32 to *string.
    25  func Uint32ToStringPtr(v uint32) *string {
    26  	r := Uint32ToString(v)
    27  	return &r
    28  }
    29  
    30  // Uint32ToBool converts uint32 to bool.
    31  func Uint32ToBool(v uint32) bool {
    32  	return v != 0
    33  }
    34  
    35  // Uint32ToBoolPtr converts uint32 to *bool.
    36  func Uint32ToBoolPtr(v uint32) *bool {
    37  	r := Uint32ToBool(v)
    38  	return &r
    39  }
    40  
    41  // Uint32ToFloat32 converts uint32 to float32.
    42  func Uint32ToFloat32(v uint32) float32 {
    43  	return float32(v)
    44  }
    45  
    46  // Uint32ToFloat32Ptr converts uint32 to *float32.
    47  func Uint32ToFloat32Ptr(v uint32) *float32 {
    48  	r := Uint32ToFloat32(v)
    49  	return &r
    50  }
    51  
    52  // Uint32ToFloat64 converts uint32 to float64.
    53  func Uint32ToFloat64(v uint32) float64 {
    54  	return float64(v)
    55  }
    56  
    57  // Uint32ToFloat64Ptr converts uint32 to *float64.
    58  func Uint32ToFloat64Ptr(v uint32) *float64 {
    59  	r := Uint32ToFloat64(v)
    60  	return &r
    61  }
    62  
    63  // Uint32ToInt converts uint32 to int.
    64  func Uint32ToInt(v uint32) int {
    65  	return int(v)
    66  }
    67  
    68  // Uint32ToIntPtr converts uint32 to *int.
    69  func Uint32ToIntPtr(v uint32) *int {
    70  	r := Uint32ToInt(v)
    71  	return &r
    72  }
    73  
    74  // Uint32ToInt8 converts uint32 to int8.
    75  func Uint32ToInt8(v uint32) (int8, error) {
    76  	if v > math.MaxInt8 {
    77  		return 0, errOverflowValue
    78  	}
    79  	return int8(v), nil
    80  }
    81  
    82  // Uint32ToInt8Ptr converts uint32 to *int8.
    83  func Uint32ToInt8Ptr(v uint32) (*int8, error) {
    84  	r, err := Uint32ToInt8(v)
    85  	return &r, err
    86  }
    87  
    88  // Uint32ToInt16 converts uint32 to int16.
    89  func Uint32ToInt16(v uint32) (int16, error) {
    90  	if v > math.MaxInt16 {
    91  		return 0, errOverflowValue
    92  	}
    93  	return int16(v), nil
    94  }
    95  
    96  // Uint32ToInt16Ptr converts uint32 to *int16.
    97  func Uint32ToInt16Ptr(v uint32) (*int16, error) {
    98  	r, err := Uint32ToInt16(v)
    99  	return &r, err
   100  }
   101  
   102  // Uint32ToInt32 converts uint32 to int32.
   103  func Uint32ToInt32(v uint32) (int32, error) {
   104  	if v > math.MaxInt32 {
   105  		return 0, errOverflowValue
   106  	}
   107  	return int32(v), nil
   108  }
   109  
   110  // Uint32ToInt32Ptr converts uint32 to *int32.
   111  func Uint32ToInt32Ptr(v uint32) (*int32, error) {
   112  	r, err := Uint32ToInt32(v)
   113  	return &r, err
   114  }
   115  
   116  // Uint32ToInt64 converts uint32 to int64.
   117  func Uint32ToInt64(v uint32) int64 {
   118  	return int64(v)
   119  }
   120  
   121  // Uint32ToInt64Ptr converts uint32 to *int64.
   122  func Uint32ToInt64Ptr(v uint32) *int64 {
   123  	r := Uint32ToInt64(v)
   124  	return &r
   125  }
   126  
   127  // Uint32ToUint converts uint32 to uint.
   128  func Uint32ToUint(v uint32) uint {
   129  	return uint(v)
   130  }
   131  
   132  // Uint32ToUintPtr converts uint32 to *uint.
   133  func Uint32ToUintPtr(v uint32) *uint {
   134  	r := Uint32ToUint(v)
   135  	return &r
   136  }
   137  
   138  // Uint32ToUint8 converts uint32 to uint8.
   139  func Uint32ToUint8(v uint32) (uint8, error) {
   140  	if v > math.MaxUint8 {
   141  		return 0, errOverflowValue
   142  	}
   143  	return uint8(v), nil
   144  }
   145  
   146  // Uint32ToUint8Ptr converts uint32 to *uint8.
   147  func Uint32ToUint8Ptr(v uint32) (*uint8, error) {
   148  	r, err := Uint32ToUint8(v)
   149  	return &r, err
   150  }
   151  
   152  // Uint32ToUint16 converts uint32 to uint16.
   153  func Uint32ToUint16(v uint32) (uint16, error) {
   154  	if v > math.MaxUint16 {
   155  		return 0, errOverflowValue
   156  	}
   157  	return uint16(v), nil
   158  }
   159  
   160  // Uint32ToUint16Ptr converts uint32 to *uint16.
   161  func Uint32ToUint16Ptr(v uint32) (*uint16, error) {
   162  	r, err := Uint32ToUint16(v)
   163  	return &r, err
   164  }
   165  
   166  // Uint32ToUint32Ptr converts uint32 to *uint32.
   167  func Uint32ToUint32Ptr(v uint32) *uint32 {
   168  	return &v
   169  }
   170  
   171  // Uint32ToUint64 converts uint32 to uint64.
   172  func Uint32ToUint64(v uint32) uint64 {
   173  	return uint64(v)
   174  }
   175  
   176  // Uint32ToUint64Ptr converts uint32 to *uint64.
   177  func Uint32ToUint64Ptr(v uint32) *uint64 {
   178  	r := Uint32ToUint64(v)
   179  	return &r
   180  }