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

     1  package ameda
     2  
     3  import (
     4  	"strconv"
     5  )
     6  
     7  // Int8ToInterface converts int8 to interface.
     8  func Int8ToInterface(v int8) interface{} {
     9  	return v
    10  }
    11  
    12  // Int8ToInterfacePtr converts int8 to *interface.
    13  func Int8ToInterfacePtr(v int8) *interface{} {
    14  	r := Int8ToInterface(v)
    15  	return &r
    16  }
    17  
    18  // Int8ToString converts int8 to string.
    19  func Int8ToString(v int8) string {
    20  	return strconv.FormatInt(int64(v), 10)
    21  }
    22  
    23  // Int8ToStringPtr converts int8 to *string.
    24  func Int8ToStringPtr(v int8) *string {
    25  	r := Int8ToString(v)
    26  	return &r
    27  }
    28  
    29  // Int8ToBool converts int8 to bool.
    30  func Int8ToBool(v int8) bool {
    31  	return v != 0
    32  }
    33  
    34  // Int8ToBoolPtr converts int8 to *bool.
    35  func Int8ToBoolPtr(v int8) *bool {
    36  	r := Int8ToBool(v)
    37  	return &r
    38  }
    39  
    40  // Int8ToFloat32 converts int8 to float32.
    41  func Int8ToFloat32(v int8) float32 {
    42  	return float32(v)
    43  }
    44  
    45  // Int8ToFloat32Ptr converts int8 to *float32.
    46  func Int8ToFloat32Ptr(v int8) *float32 {
    47  	r := Int8ToFloat32(v)
    48  	return &r
    49  }
    50  
    51  // Int8ToFloat64 converts int8 to float64.
    52  func Int8ToFloat64(v int8) float64 {
    53  	return float64(v)
    54  }
    55  
    56  // Int8ToFloat64Ptr converts int8 to *float64.
    57  func Int8ToFloat64Ptr(v int8) *float64 {
    58  	r := Int8ToFloat64(v)
    59  	return &r
    60  }
    61  
    62  // Int8ToInt converts int8 to int.
    63  func Int8ToInt(v int8) int {
    64  	return int(v)
    65  }
    66  
    67  // Int8ToIntPtr converts int8 to *int.
    68  func Int8ToIntPtr(v int8) *int {
    69  	r := Int8ToInt(v)
    70  	return &r
    71  }
    72  
    73  // Int8ToInt8Ptr converts int8 to *int8.
    74  func Int8ToInt8Ptr(v int8) *int8 {
    75  	return &v
    76  }
    77  
    78  // Int8ToInt16 converts int8 to int16.
    79  func Int8ToInt16(v int8) int16 {
    80  	return int16(v)
    81  }
    82  
    83  // Int8ToInt16Ptr converts int8 to *int16.
    84  func Int8ToInt16Ptr(v int8) *int16 {
    85  	r := Int8ToInt16(v)
    86  	return &r
    87  }
    88  
    89  // Int8ToInt32 converts int8 to int32.
    90  func Int8ToInt32(v int8) int32 {
    91  	return int32(v)
    92  }
    93  
    94  // Int8ToInt32Ptr converts int8 to *int32.
    95  func Int8ToInt32Ptr(v int8) *int32 {
    96  	r := Int8ToInt32(v)
    97  	return &r
    98  }
    99  
   100  // Int8ToInt64 converts int8 to int64.
   101  func Int8ToInt64(v int8) int64 {
   102  	return int64(v)
   103  }
   104  
   105  // Int8ToInt64Ptr converts int8 to *int64.
   106  func Int8ToInt64Ptr(v int8) *int64 {
   107  	r := Int8ToInt64(v)
   108  	return &r
   109  }
   110  
   111  // Int8ToUint converts int8 to uint.
   112  func Int8ToUint(v int8) (uint, error) {
   113  	if v < 0 {
   114  		return 0, errNegativeValue
   115  	}
   116  	return uint(v), nil
   117  }
   118  
   119  // Int8ToUintPtr converts int8 to *uint.
   120  func Int8ToUintPtr(v int8) (*uint, error) {
   121  	r, err := Int8ToUint(v)
   122  	return &r, err
   123  }
   124  
   125  // Int8ToUint8 converts int8 to uint8.
   126  func Int8ToUint8(v int8) (uint8, error) {
   127  	if v < 0 {
   128  		return 0, errNegativeValue
   129  	}
   130  	return uint8(v), nil
   131  }
   132  
   133  // Int8ToUint8Ptr converts int8 to *uint8.
   134  func Int8ToUint8Ptr(v int8) (*uint8, error) {
   135  	r, err := Int8ToUint8(v)
   136  	return &r, err
   137  }
   138  
   139  // Int8ToUint16 converts int8 to uint16.
   140  func Int8ToUint16(v int8) (uint16, error) {
   141  	if v < 0 {
   142  		return 0, errNegativeValue
   143  	}
   144  	return uint16(v), nil
   145  }
   146  
   147  // Int8ToUint16Ptr converts int8 to *uint16.
   148  func Int8ToUint16Ptr(v int8) (*uint16, error) {
   149  	r, err := Int8ToUint16(v)
   150  	return &r, err
   151  }
   152  
   153  // Int8ToUint32 converts int8 to uint32.
   154  func Int8ToUint32(v int8) (uint32, error) {
   155  	if v < 0 {
   156  		return 0, errNegativeValue
   157  	}
   158  	return uint32(v), nil
   159  }
   160  
   161  // Int8ToUint32Ptr converts int8 to *uint32.
   162  func Int8ToUint32Ptr(v int8) (*uint32, error) {
   163  	r, err := Int8ToUint32(v)
   164  	return &r, err
   165  }
   166  
   167  // Int8ToUint64 converts int8 to uint64.
   168  func Int8ToUint64(v int8) (uint64, error) {
   169  	if v < 0 {
   170  		return 0, errNegativeValue
   171  	}
   172  	return uint64(v), nil
   173  }
   174  
   175  // Int8ToUint64Ptr converts int8 to *uint64.
   176  func Int8ToUint64Ptr(v int8) (*uint64, error) {
   177  	r, err := Int8ToUint64(v)
   178  	return &r, err
   179  }