github.com/gogo/protobuf@v1.3.2/types/wrappers_gogo.go (about)

     1  // Protocol Buffers for Go with Gadgets
     2  //
     3  // Copyright (c) 2018, The GoGo Authors. All rights reserved.
     4  // http://github.com/gogo/protobuf
     5  //
     6  // Redistribution and use in source and binary forms, with or without
     7  // modification, are permitted provided that the following conditions are
     8  // met:
     9  //
    10  //     * Redistributions of source code must retain the above copyright
    11  // notice, this list of conditions and the following disclaimer.
    12  //     * Redistributions in binary form must reproduce the above
    13  // copyright notice, this list of conditions and the following disclaimer
    14  // in the documentation and/or other materials provided with the
    15  // distribution.
    16  //
    17  // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
    18  // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
    19  // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
    20  // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
    21  // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
    22  // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
    23  // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
    24  // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
    25  // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
    26  // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
    27  // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    28  
    29  package types
    30  
    31  func NewPopulatedStdDouble(r randyWrappers, easy bool) *float64 {
    32  	v := NewPopulatedDoubleValue(r, easy)
    33  	return &v.Value
    34  }
    35  
    36  func SizeOfStdDouble(v float64) int {
    37  	pv := &DoubleValue{Value: v}
    38  	return pv.Size()
    39  }
    40  
    41  func StdDoubleMarshal(v float64) ([]byte, error) {
    42  	size := SizeOfStdDouble(v)
    43  	buf := make([]byte, size)
    44  	_, err := StdDoubleMarshalTo(v, buf)
    45  	return buf, err
    46  }
    47  
    48  func StdDoubleMarshalTo(v float64, data []byte) (int, error) {
    49  	pv := &DoubleValue{Value: v}
    50  	return pv.MarshalTo(data)
    51  }
    52  
    53  func StdDoubleUnmarshal(v *float64, data []byte) error {
    54  	pv := &DoubleValue{}
    55  	if err := pv.Unmarshal(data); err != nil {
    56  		return err
    57  	}
    58  	*v = pv.Value
    59  	return nil
    60  }
    61  func NewPopulatedStdFloat(r randyWrappers, easy bool) *float32 {
    62  	v := NewPopulatedFloatValue(r, easy)
    63  	return &v.Value
    64  }
    65  
    66  func SizeOfStdFloat(v float32) int {
    67  	pv := &FloatValue{Value: v}
    68  	return pv.Size()
    69  }
    70  
    71  func StdFloatMarshal(v float32) ([]byte, error) {
    72  	size := SizeOfStdFloat(v)
    73  	buf := make([]byte, size)
    74  	_, err := StdFloatMarshalTo(v, buf)
    75  	return buf, err
    76  }
    77  
    78  func StdFloatMarshalTo(v float32, data []byte) (int, error) {
    79  	pv := &FloatValue{Value: v}
    80  	return pv.MarshalTo(data)
    81  }
    82  
    83  func StdFloatUnmarshal(v *float32, data []byte) error {
    84  	pv := &FloatValue{}
    85  	if err := pv.Unmarshal(data); err != nil {
    86  		return err
    87  	}
    88  	*v = pv.Value
    89  	return nil
    90  }
    91  func NewPopulatedStdInt64(r randyWrappers, easy bool) *int64 {
    92  	v := NewPopulatedInt64Value(r, easy)
    93  	return &v.Value
    94  }
    95  
    96  func SizeOfStdInt64(v int64) int {
    97  	pv := &Int64Value{Value: v}
    98  	return pv.Size()
    99  }
   100  
   101  func StdInt64Marshal(v int64) ([]byte, error) {
   102  	size := SizeOfStdInt64(v)
   103  	buf := make([]byte, size)
   104  	_, err := StdInt64MarshalTo(v, buf)
   105  	return buf, err
   106  }
   107  
   108  func StdInt64MarshalTo(v int64, data []byte) (int, error) {
   109  	pv := &Int64Value{Value: v}
   110  	return pv.MarshalTo(data)
   111  }
   112  
   113  func StdInt64Unmarshal(v *int64, data []byte) error {
   114  	pv := &Int64Value{}
   115  	if err := pv.Unmarshal(data); err != nil {
   116  		return err
   117  	}
   118  	*v = pv.Value
   119  	return nil
   120  }
   121  func NewPopulatedStdUInt64(r randyWrappers, easy bool) *uint64 {
   122  	v := NewPopulatedUInt64Value(r, easy)
   123  	return &v.Value
   124  }
   125  
   126  func SizeOfStdUInt64(v uint64) int {
   127  	pv := &UInt64Value{Value: v}
   128  	return pv.Size()
   129  }
   130  
   131  func StdUInt64Marshal(v uint64) ([]byte, error) {
   132  	size := SizeOfStdUInt64(v)
   133  	buf := make([]byte, size)
   134  	_, err := StdUInt64MarshalTo(v, buf)
   135  	return buf, err
   136  }
   137  
   138  func StdUInt64MarshalTo(v uint64, data []byte) (int, error) {
   139  	pv := &UInt64Value{Value: v}
   140  	return pv.MarshalTo(data)
   141  }
   142  
   143  func StdUInt64Unmarshal(v *uint64, data []byte) error {
   144  	pv := &UInt64Value{}
   145  	if err := pv.Unmarshal(data); err != nil {
   146  		return err
   147  	}
   148  	*v = pv.Value
   149  	return nil
   150  }
   151  func NewPopulatedStdInt32(r randyWrappers, easy bool) *int32 {
   152  	v := NewPopulatedInt32Value(r, easy)
   153  	return &v.Value
   154  }
   155  
   156  func SizeOfStdInt32(v int32) int {
   157  	pv := &Int32Value{Value: v}
   158  	return pv.Size()
   159  }
   160  
   161  func StdInt32Marshal(v int32) ([]byte, error) {
   162  	size := SizeOfStdInt32(v)
   163  	buf := make([]byte, size)
   164  	_, err := StdInt32MarshalTo(v, buf)
   165  	return buf, err
   166  }
   167  
   168  func StdInt32MarshalTo(v int32, data []byte) (int, error) {
   169  	pv := &Int32Value{Value: v}
   170  	return pv.MarshalTo(data)
   171  }
   172  
   173  func StdInt32Unmarshal(v *int32, data []byte) error {
   174  	pv := &Int32Value{}
   175  	if err := pv.Unmarshal(data); err != nil {
   176  		return err
   177  	}
   178  	*v = pv.Value
   179  	return nil
   180  }
   181  func NewPopulatedStdUInt32(r randyWrappers, easy bool) *uint32 {
   182  	v := NewPopulatedUInt32Value(r, easy)
   183  	return &v.Value
   184  }
   185  
   186  func SizeOfStdUInt32(v uint32) int {
   187  	pv := &UInt32Value{Value: v}
   188  	return pv.Size()
   189  }
   190  
   191  func StdUInt32Marshal(v uint32) ([]byte, error) {
   192  	size := SizeOfStdUInt32(v)
   193  	buf := make([]byte, size)
   194  	_, err := StdUInt32MarshalTo(v, buf)
   195  	return buf, err
   196  }
   197  
   198  func StdUInt32MarshalTo(v uint32, data []byte) (int, error) {
   199  	pv := &UInt32Value{Value: v}
   200  	return pv.MarshalTo(data)
   201  }
   202  
   203  func StdUInt32Unmarshal(v *uint32, data []byte) error {
   204  	pv := &UInt32Value{}
   205  	if err := pv.Unmarshal(data); err != nil {
   206  		return err
   207  	}
   208  	*v = pv.Value
   209  	return nil
   210  }
   211  func NewPopulatedStdBool(r randyWrappers, easy bool) *bool {
   212  	v := NewPopulatedBoolValue(r, easy)
   213  	return &v.Value
   214  }
   215  
   216  func SizeOfStdBool(v bool) int {
   217  	pv := &BoolValue{Value: v}
   218  	return pv.Size()
   219  }
   220  
   221  func StdBoolMarshal(v bool) ([]byte, error) {
   222  	size := SizeOfStdBool(v)
   223  	buf := make([]byte, size)
   224  	_, err := StdBoolMarshalTo(v, buf)
   225  	return buf, err
   226  }
   227  
   228  func StdBoolMarshalTo(v bool, data []byte) (int, error) {
   229  	pv := &BoolValue{Value: v}
   230  	return pv.MarshalTo(data)
   231  }
   232  
   233  func StdBoolUnmarshal(v *bool, data []byte) error {
   234  	pv := &BoolValue{}
   235  	if err := pv.Unmarshal(data); err != nil {
   236  		return err
   237  	}
   238  	*v = pv.Value
   239  	return nil
   240  }
   241  func NewPopulatedStdString(r randyWrappers, easy bool) *string {
   242  	v := NewPopulatedStringValue(r, easy)
   243  	return &v.Value
   244  }
   245  
   246  func SizeOfStdString(v string) int {
   247  	pv := &StringValue{Value: v}
   248  	return pv.Size()
   249  }
   250  
   251  func StdStringMarshal(v string) ([]byte, error) {
   252  	size := SizeOfStdString(v)
   253  	buf := make([]byte, size)
   254  	_, err := StdStringMarshalTo(v, buf)
   255  	return buf, err
   256  }
   257  
   258  func StdStringMarshalTo(v string, data []byte) (int, error) {
   259  	pv := &StringValue{Value: v}
   260  	return pv.MarshalTo(data)
   261  }
   262  
   263  func StdStringUnmarshal(v *string, data []byte) error {
   264  	pv := &StringValue{}
   265  	if err := pv.Unmarshal(data); err != nil {
   266  		return err
   267  	}
   268  	*v = pv.Value
   269  	return nil
   270  }
   271  func NewPopulatedStdBytes(r randyWrappers, easy bool) *[]byte {
   272  	v := NewPopulatedBytesValue(r, easy)
   273  	return &v.Value
   274  }
   275  
   276  func SizeOfStdBytes(v []byte) int {
   277  	pv := &BytesValue{Value: v}
   278  	return pv.Size()
   279  }
   280  
   281  func StdBytesMarshal(v []byte) ([]byte, error) {
   282  	size := SizeOfStdBytes(v)
   283  	buf := make([]byte, size)
   284  	_, err := StdBytesMarshalTo(v, buf)
   285  	return buf, err
   286  }
   287  
   288  func StdBytesMarshalTo(v []byte, data []byte) (int, error) {
   289  	pv := &BytesValue{Value: v}
   290  	return pv.MarshalTo(data)
   291  }
   292  
   293  func StdBytesUnmarshal(v *[]byte, data []byte) error {
   294  	pv := &BytesValue{}
   295  	if err := pv.Unmarshal(data); err != nil {
   296  		return err
   297  	}
   298  	*v = pv.Value
   299  	return nil
   300  }