types.go

Documentation: google.golang.org/api/googleapi

     1  // Copyright 2013 Google LLC. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package googleapi
     6  
     7  import (
     8  	"encoding/json"
     9  	"errors"
    10  	"strconv"
    11  )
    12  
    13  // Int64s is a slice of int64s that marshal as quoted strings in JSON.
    14  type Int64s []int64
    15  
    16  func (q *Int64s) UnmarshalJSON(raw []byte) error {
    17  	*q = (*q)[:0]
    18  	var ss []string
    19  	if err := json.Unmarshal(raw, &ss); err != nil {
    20  		return err
    21  	}
    22  	for _, s := range ss {
    23  		v, err := strconv.ParseInt(s, 10, 64)
    24  		if err != nil {
    25  			return err
    26  		}
    27  		*q = append(*q, int64(v))
    28  	}
    29  	return nil
    30  }
    31  
    32  // Int32s is a slice of int32s that marshal as quoted strings in JSON.
    33  type Int32s []int32
    34  
    35  func (q *Int32s) UnmarshalJSON(raw []byte) error {
    36  	*q = (*q)[:0]
    37  	var ss []string
    38  	if err := json.Unmarshal(raw, &ss); err != nil {
    39  		return err
    40  	}
    41  	for _, s := range ss {
    42  		v, err := strconv.ParseInt(s, 10, 32)
    43  		if err != nil {
    44  			return err
    45  		}
    46  		*q = append(*q, int32(v))
    47  	}
    48  	return nil
    49  }
    50  
    51  // Uint64s is a slice of uint64s that marshal as quoted strings in JSON.
    52  type Uint64s []uint64
    53  
    54  func (q *Uint64s) UnmarshalJSON(raw []byte) error {
    55  	*q = (*q)[:0]
    56  	var ss []string
    57  	if err := json.Unmarshal(raw, &ss); err != nil {
    58  		return err
    59  	}
    60  	for _, s := range ss {
    61  		v, err := strconv.ParseUint(s, 10, 64)
    62  		if err != nil {
    63  			return err
    64  		}
    65  		*q = append(*q, uint64(v))
    66  	}
    67  	return nil
    68  }
    69  
    70  // Uint32s is a slice of uint32s that marshal as quoted strings in JSON.
    71  type Uint32s []uint32
    72  
    73  func (q *Uint32s) UnmarshalJSON(raw []byte) error {
    74  	*q = (*q)[:0]
    75  	var ss []string
    76  	if err := json.Unmarshal(raw, &ss); err != nil {
    77  		return err
    78  	}
    79  	for _, s := range ss {
    80  		v, err := strconv.ParseUint(s, 10, 32)
    81  		if err != nil {
    82  			return err
    83  		}
    84  		*q = append(*q, uint32(v))
    85  	}
    86  	return nil
    87  }
    88  
    89  // Float64s is a slice of float64s that marshal as quoted strings in JSON.
    90  type Float64s []float64
    91  
    92  func (q *Float64s) UnmarshalJSON(raw []byte) error {
    93  	*q = (*q)[:0]
    94  	var ss []string
    95  	if err := json.Unmarshal(raw, &ss); err != nil {
    96  		return err
    97  	}
    98  	for _, s := range ss {
    99  		v, err := strconv.ParseFloat(s, 64)
   100  		if err != nil {
   101  			return err
   102  		}
   103  		*q = append(*q, float64(v))
   104  	}
   105  	return nil
   106  }
   107  
   108  func quotedList(n int, fn func(dst []byte, i int) []byte) ([]byte, error) {
   109  	dst := make([]byte, 0, 2+n*10) // somewhat arbitrary
   110  	dst = append(dst, '[')
   111  	for i := 0; i < n; i++ {
   112  		if i > 0 {
   113  			dst = append(dst, ',')
   114  		}
   115  		dst = append(dst, '"')
   116  		dst = fn(dst, i)
   117  		dst = append(dst, '"')
   118  	}
   119  	dst = append(dst, ']')
   120  	return dst, nil
   121  }
   122  
   123  func (q Int64s) MarshalJSON() ([]byte, error) {
   124  	return quotedList(len(q), func(dst []byte, i int) []byte {
   125  		return strconv.AppendInt(dst, q[i], 10)
   126  	})
   127  }
   128  
   129  func (q Int32s) MarshalJSON() ([]byte, error) {
   130  	return quotedList(len(q), func(dst []byte, i int) []byte {
   131  		return strconv.AppendInt(dst, int64(q[i]), 10)
   132  	})
   133  }
   134  
   135  func (q Uint64s) MarshalJSON() ([]byte, error) {
   136  	return quotedList(len(q), func(dst []byte, i int) []byte {
   137  		return strconv.AppendUint(dst, q[i], 10)
   138  	})
   139  }
   140  
   141  func (q Uint32s) MarshalJSON() ([]byte, error) {
   142  	return quotedList(len(q), func(dst []byte, i int) []byte {
   143  		return strconv.AppendUint(dst, uint64(q[i]), 10)
   144  	})
   145  }
   146  
   147  func (q Float64s) MarshalJSON() ([]byte, error) {
   148  	return quotedList(len(q), func(dst []byte, i int) []byte {
   149  		return strconv.AppendFloat(dst, q[i], 'g', -1, 64)
   150  	})
   151  }
   152  
   153  // RawMessage is a raw encoded JSON value.
   154  // It is identical to json.RawMessage, except it does not suffer from
   155  // https://golang.org/issue/14493.
   156  type RawMessage []byte
   157  
   158  // MarshalJSON returns m.
   159  func (m RawMessage) MarshalJSON() ([]byte, error) {
   160  	return m, nil
   161  }
   162  
   163  // UnmarshalJSON sets *m to a copy of data.
   164  func (m *RawMessage) UnmarshalJSON(data []byte) error {
   165  	if m == nil {
   166  		return errors.New("googleapi.RawMessage: UnmarshalJSON on nil pointer")
   167  	}
   168  	*m = append((*m)[:0], data...)
   169  	return nil
   170  }
   171  
   172  /*
   173   * Helper routines for simplifying the creation of optional fields of basic type.
   174   */
   175  
   176  // Bool is a helper routine that allocates a new bool value
   177  // to store v and returns a pointer to it.
   178  func Bool(v bool) *bool { return &v }
   179  
   180  // Int32 is a helper routine that allocates a new int32 value
   181  // to store v and returns a pointer to it.
   182  func Int32(v int32) *int32 { return &v }
   183  
   184  // Int64 is a helper routine that allocates a new int64 value
   185  // to store v and returns a pointer to it.
   186  func Int64(v int64) *int64 { return &v }
   187  
   188  // Float64 is a helper routine that allocates a new float64 value
   189  // to store v and returns a pointer to it.
   190  func Float64(v float64) *float64 { return &v }
   191  
   192  // Uint32 is a helper routine that allocates a new uint32 value
   193  // to store v and returns a pointer to it.
   194  func Uint32(v uint32) *uint32 { return &v }
   195  
   196  // Uint64 is a helper routine that allocates a new uint64 value
   197  // to store v and returns a pointer to it.
   198  func Uint64(v uint64) *uint64 { return &v }
   199  
   200  // String is a helper routine that allocates a new string value
   201  // to store v and returns a pointer to it.
   202  func String(v string) *string { return &v }
   203
View as plain text