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

     1  package ameda
     2  
     3  import (
     4  	"math"
     5  	"strconv"
     6  )
     7  
     8  // Int32ToInterface converts int32 to interface.
     9  func Int32ToInterface(v int32) interface{} {
    10  	return v
    11  }
    12  
    13  // Int32ToInterfacePtr converts int32 to *interface.
    14  func Int32ToInterfacePtr(v int32) *interface{} {
    15  	r := Int32ToInterface(v)
    16  	return &r
    17  }
    18  
    19  // Int32ToString converts int32 to string.
    20  func Int32ToString(v int32) string {
    21  	return strconv.FormatInt(int64(v), 10)
    22  }
    23  
    24  // Int32ToStringPtr converts int32 to *string.
    25  func Int32ToStringPtr(v int32) *string {
    26  	r := Int32ToString(v)
    27  	return &r
    28  }
    29  
    30  // Int32ToBool converts int32 to bool.
    31  func Int32ToBool(v int32) bool {
    32  	return v != 0
    33  }
    34  
    35  // Int32ToBoolPtr converts int32 to *bool.
    36  func Int32ToBoolPtr(v int32) *bool {
    37  	r := Int32ToBool(v)
    38  	return &r
    39  }
    40  
    41  // Int32ToFloat32 converts int32 to float32.
    42  func Int32ToFloat32(v int32) float32 {
    43  	return float32(v)
    44  }
    45  
    46  // Int32ToFloat32Ptr converts int32 to *float32.
    47  func Int32ToFloat32Ptr(v int32) *float32 {
    48  	r := Int32ToFloat32(v)
    49  	return &r
    50  }
    51  
    52  // Int32ToFloat64 converts int32 to float64.
    53  func Int32ToFloat64(v int32) float64 {
    54  	return float64(v)
    55  }
    56  
    57  // Int32ToFloat64Ptr converts int32 to *float64.
    58  func Int32ToFloat64Ptr(v int32) *float64 {
    59  	r := Int32ToFloat64(v)
    60  	return &r
    61  }
    62  
    63  // Int32ToInt converts int32 to int.
    64  func Int32ToInt(v int32) int {
    65  	return int(v)
    66  }
    67  
    68  // Int32ToIntPtr converts int32 to *int.
    69  func Int32ToIntPtr(v int32) *int {
    70  	r := Int32ToInt(v)
    71  	return &r
    72  }
    73  
    74  // Int32ToInt8 converts int32 to int8.
    75  func Int32ToInt8(v int32) (int8, error) {
    76  	if v > math.MaxInt8 || v < math.MinInt8 {
    77  		return 0, errOverflowValue
    78  	}
    79  	return int8(v), nil
    80  }
    81  
    82  // Int32ToInt8Ptr converts int32 to *int8.
    83  func Int32ToInt8Ptr(v int32) (*int8, error) {
    84  	r, err := Int32ToInt8(v)
    85  	return &r, err
    86  }
    87  
    88  // Int32ToInt16 converts int32 to int16.
    89  func Int32ToInt16(v int32) (int16, error) {
    90  	if v > math.MaxInt16 || v < math.MinInt16 {
    91  		return 0, errOverflowValue
    92  	}
    93  	return int16(v), nil
    94  }
    95  
    96  // Int32ToInt16Ptr converts int32 to *int16.
    97  func Int32ToInt16Ptr(v int32) (*int16, error) {
    98  	r, err := Int32ToInt16(v)
    99  	return &r, err
   100  }
   101  
   102  // Int32ToInt32Ptr converts int32 to *int32.
   103  func Int32ToInt32Ptr(v int32) *int32 {
   104  	return &v
   105  }
   106  
   107  // Int32ToInt64 converts int32 to int64.
   108  func Int32ToInt64(v int32) int64 {
   109  	return int64(v)
   110  }
   111  
   112  // Int32ToInt64Ptr converts int32 to *int64.
   113  func Int32ToInt64Ptr(v int32) *int64 {
   114  	r := Int32ToInt64(v)
   115  	return &r
   116  }
   117  
   118  // Int32ToUint converts int32 to uint.
   119  func Int32ToUint(v int32) (uint, error) {
   120  	if v < 0 {
   121  		return 0, errNegativeValue
   122  	}
   123  	return uint(v), nil
   124  }
   125  
   126  // Int32ToUintPtr converts int32 to *uint.
   127  func Int32ToUintPtr(v int32) (*uint, error) {
   128  	r, err := Int32ToUint(v)
   129  	return &r, err
   130  }
   131  
   132  // Int32ToUint8 converts int32 to uint8.
   133  func Int32ToUint8(v int32) (uint8, error) {
   134  	if v < 0 {
   135  		return 0, errNegativeValue
   136  	}
   137  	if v > math.MaxUint8 {
   138  		return 0, errOverflowValue
   139  	}
   140  	return uint8(v), nil
   141  }
   142  
   143  // Int32ToUint8Ptr converts int32 to *uint8.
   144  func Int32ToUint8Ptr(v int32) (*uint8, error) {
   145  	r, err := Int32ToUint8(v)
   146  	return &r, err
   147  }
   148  
   149  // Int32ToUint16 converts int32 to uint16.
   150  func Int32ToUint16(v int32) (uint16, error) {
   151  	if v < 0 {
   152  		return 0, errNegativeValue
   153  	}
   154  	if v > math.MaxUint16 {
   155  		return 0, errOverflowValue
   156  	}
   157  	return uint16(v), nil
   158  }
   159  
   160  // Int32ToUint16Ptr converts int32 to *uint16.
   161  func Int32ToUint16Ptr(v int32) (*uint16, error) {
   162  	r, err := Int32ToUint16(v)
   163  	return &r, err
   164  }
   165  
   166  // Int32ToUint32 converts int32 to uint32.
   167  func Int32ToUint32(v int32) (uint32, error) {
   168  	if v < 0 {
   169  		return 0, errNegativeValue
   170  	}
   171  	return uint32(v), nil
   172  }
   173  
   174  // Int32ToUint32Ptr converts int32 to *uint32.
   175  func Int32ToUint32Ptr(v int32) (*uint32, error) {
   176  	r, err := Int32ToUint32(v)
   177  	return &r, err
   178  }
   179  
   180  // Int32ToUint64 converts int32 to uint64.
   181  func Int32ToUint64(v int32) (uint64, error) {
   182  	if v < 0 {
   183  		return 0, errNegativeValue
   184  	}
   185  	return uint64(v), nil
   186  }
   187  
   188  // Int32ToUint64Ptr converts int32 to *uint64.
   189  func Int32ToUint64Ptr(v int32) (*uint64, error) {
   190  	r, err := Int32ToUint64(v)
   191  	return &r, err
   192  }