// Code generated by ogen, DO NOT EDIT.
package api
import (
"math/bits"
"strconv"
"github.com/go-faster/errors"
"github.com/go-faster/jx"
"github.com/ogen-go/ogen/validate"
)
// Encode implements json.Marshaler.
func (s *Base) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *Base) encodeFields(e *jx.Encoder) {
{
if s.ID.Set {
e.FieldStart("id")
s.ID.Encode(e)
}
}
{
if s.Name.Set {
e.FieldStart("name")
s.Name.Encode(e)
}
}
{
if s.PermissionLevel.Set {
e.FieldStart("permissionLevel")
s.PermissionLevel.Encode(e)
}
}
}
var jsonFieldsNameOfBase = [3]string{
0: "id",
1: "name",
2: "permissionLevel",
}
// Decode decodes Base from json.
func (s *Base) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode Base to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "id":
if err := func() error {
s.ID.Reset()
if err := s.ID.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"id\"")
}
case "name":
if err := func() error {
s.Name.Reset()
if err := s.Name.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"name\"")
}
case "permissionLevel":
if err := func() error {
s.PermissionLevel.Reset()
if err := s.PermissionLevel.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"permissionLevel\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode Base")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *Base) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Base) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *BaseListResponse) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *BaseListResponse) encodeFields(e *jx.Encoder) {
{
if s.Bases != nil {
e.FieldStart("bases")
e.ArrStart()
for _, elem := range s.Bases {
elem.Encode(e)
}
e.ArrEnd()
}
}
}
var jsonFieldsNameOfBaseListResponse = [1]string{
0: "bases",
}
// Decode decodes BaseListResponse from json.
func (s *BaseListResponse) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode BaseListResponse to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "bases":
if err := func() error {
s.Bases = make([]Base, 0)
if err := d.Arr(func(d *jx.Decoder) error {
var elem Base
if err := elem.Decode(d); err != nil {
return err
}
s.Bases = append(s.Bases, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"bases\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode BaseListResponse")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *BaseListResponse) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *BaseListResponse) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *CreateRecordsReq) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *CreateRecordsReq) encodeFields(e *jx.Encoder) {
{
e.FieldStart("records")
e.ArrStart()
for _, elem := range s.Records {
elem.Encode(e)
}
e.ArrEnd()
}
{
if s.Typecast.Set {
e.FieldStart("typecast")
s.Typecast.Encode(e)
}
}
}
var jsonFieldsNameOfCreateRecordsReq = [2]string{
0: "records",
1: "typecast",
}
// Decode decodes CreateRecordsReq from json.
func (s *CreateRecordsReq) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode CreateRecordsReq to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "records":
requiredBitSet[0] |= 1 << 0
if err := func() error {
s.Records = make([]CreateRecordsReqRecordsItem, 0)
if err := d.Arr(func(d *jx.Decoder) error {
var elem CreateRecordsReqRecordsItem
if err := elem.Decode(d); err != nil {
return err
}
s.Records = append(s.Records, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"records\"")
}
case "typecast":
if err := func() error {
s.Typecast.Reset()
if err := s.Typecast.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"typecast\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode CreateRecordsReq")
}
// Validate required fields.
var failures []validate.FieldError
for i, mask := range [1]uint8{
0b00000001,
} {
if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
// Mask only required fields and check equality to mask using XOR.
//
// If XOR result is not zero, result is not equal to expected, so some fields are missed.
// Bits of fields which would be set are actually bits of missed fields.
missed := bits.OnesCount8(result)
for bitN := 0; bitN < missed; bitN++ {
bitIdx := bits.TrailingZeros8(result)
fieldIdx := i*8 + bitIdx
var name string
if fieldIdx < len(jsonFieldsNameOfCreateRecordsReq) {
name = jsonFieldsNameOfCreateRecordsReq[fieldIdx]
} else {
name = strconv.Itoa(fieldIdx)
}
failures = append(failures, validate.FieldError{
Name: name,
Error: validate.ErrFieldRequired,
})
// Reset bit.
result &^= 1 << bitIdx
}
}
}
if len(failures) > 0 {
return &validate.Error{Fields: failures}
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *CreateRecordsReq) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CreateRecordsReq) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *CreateRecordsReqRecordsItem) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *CreateRecordsReqRecordsItem) encodeFields(e *jx.Encoder) {
{
if s.Fields.Set {
e.FieldStart("fields")
s.Fields.Encode(e)
}
}
}
var jsonFieldsNameOfCreateRecordsReqRecordsItem = [1]string{
0: "fields",
}
// Decode decodes CreateRecordsReqRecordsItem from json.
func (s *CreateRecordsReqRecordsItem) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode CreateRecordsReqRecordsItem to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "fields":
if err := func() error {
s.Fields.Reset()
if err := s.Fields.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"fields\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode CreateRecordsReqRecordsItem")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *CreateRecordsReqRecordsItem) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CreateRecordsReqRecordsItem) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *CreateRecordsResponse) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *CreateRecordsResponse) encodeFields(e *jx.Encoder) {
{
if s.Records != nil {
e.FieldStart("records")
e.ArrStart()
for _, elem := range s.Records {
elem.Encode(e)
}
e.ArrEnd()
}
}
}
var jsonFieldsNameOfCreateRecordsResponse = [1]string{
0: "records",
}
// Decode decodes CreateRecordsResponse from json.
func (s *CreateRecordsResponse) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode CreateRecordsResponse to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "records":
if err := func() error {
s.Records = make([]Record, 0)
if err := d.Arr(func(d *jx.Decoder) error {
var elem Record
if err := elem.Decode(d); err != nil {
return err
}
s.Records = append(s.Records, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"records\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode CreateRecordsResponse")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *CreateRecordsResponse) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CreateRecordsResponse) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *CreateTableReq) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *CreateTableReq) encodeFields(e *jx.Encoder) {
{
e.FieldStart("name")
e.Str(s.Name)
}
{
if s.Description.Set {
e.FieldStart("description")
s.Description.Encode(e)
}
}
{
e.FieldStart("fields")
e.ArrStart()
for _, elem := range s.Fields {
elem.Encode(e)
}
e.ArrEnd()
}
}
var jsonFieldsNameOfCreateTableReq = [3]string{
0: "name",
1: "description",
2: "fields",
}
// Decode decodes CreateTableReq from json.
func (s *CreateTableReq) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode CreateTableReq to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "name":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Str()
s.Name = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"name\"")
}
case "description":
if err := func() error {
s.Description.Reset()
if err := s.Description.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"description\"")
}
case "fields":
requiredBitSet[0] |= 1 << 2
if err := func() error {
s.Fields = make([]Field, 0)
if err := d.Arr(func(d *jx.Decoder) error {
var elem Field
if err := elem.Decode(d); err != nil {
return err
}
s.Fields = append(s.Fields, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"fields\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode CreateTableReq")
}
// Validate required fields.
var failures []validate.FieldError
for i, mask := range [1]uint8{
0b00000101,
} {
if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
// Mask only required fields and check equality to mask using XOR.
//
// If XOR result is not zero, result is not equal to expected, so some fields are missed.
// Bits of fields which would be set are actually bits of missed fields.
missed := bits.OnesCount8(result)
for bitN := 0; bitN < missed; bitN++ {
bitIdx := bits.TrailingZeros8(result)
fieldIdx := i*8 + bitIdx
var name string
if fieldIdx < len(jsonFieldsNameOfCreateTableReq) {
name = jsonFieldsNameOfCreateTableReq[fieldIdx]
} else {
name = strconv.Itoa(fieldIdx)
}
failures = append(failures, validate.FieldError{
Name: name,
Error: validate.ErrFieldRequired,
})
// Reset bit.
result &^= 1 << bitIdx
}
}
}
if len(failures) > 0 {
return &validate.Error{Fields: failures}
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *CreateTableReq) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CreateTableReq) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *DeleteRecordsResponse) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *DeleteRecordsResponse) encodeFields(e *jx.Encoder) {
{
if s.Records != nil {
e.FieldStart("records")
e.ArrStart()
for _, elem := range s.Records {
elem.Encode(e)
}
e.ArrEnd()
}
}
}
var jsonFieldsNameOfDeleteRecordsResponse = [1]string{
0: "records",
}
// Decode decodes DeleteRecordsResponse from json.
func (s *DeleteRecordsResponse) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode DeleteRecordsResponse to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "records":
if err := func() error {
s.Records = make([]DeletedRecord, 0)
if err := d.Arr(func(d *jx.Decoder) error {
var elem DeletedRecord
if err := elem.Decode(d); err != nil {
return err
}
s.Records = append(s.Records, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"records\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode DeleteRecordsResponse")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *DeleteRecordsResponse) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *DeleteRecordsResponse) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *DeletedRecord) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *DeletedRecord) encodeFields(e *jx.Encoder) {
{
if s.ID.Set {
e.FieldStart("id")
s.ID.Encode(e)
}
}
{
if s.Deleted.Set {
e.FieldStart("deleted")
s.Deleted.Encode(e)
}
}
}
var jsonFieldsNameOfDeletedRecord = [2]string{
0: "id",
1: "deleted",
}
// Decode decodes DeletedRecord from json.
func (s *DeletedRecord) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode DeletedRecord to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "id":
if err := func() error {
s.ID.Reset()
if err := s.ID.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"id\"")
}
case "deleted":
if err := func() error {
s.Deleted.Reset()
if err := s.Deleted.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"deleted\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode DeletedRecord")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *DeletedRecord) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *DeletedRecord) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *Field) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *Field) encodeFields(e *jx.Encoder) {
{
if s.ID.Set {
e.FieldStart("id")
s.ID.Encode(e)
}
}
{
if s.Name.Set {
e.FieldStart("name")
s.Name.Encode(e)
}
}
{
if s.Type.Set {
e.FieldStart("type")
s.Type.Encode(e)
}
}
{
if s.Description.Set {
e.FieldStart("description")
s.Description.Encode(e)
}
}
{
if s.Options.Set {
e.FieldStart("options")
s.Options.Encode(e)
}
}
}
var jsonFieldsNameOfField = [5]string{
0: "id",
1: "name",
2: "type",
3: "description",
4: "options",
}
// Decode decodes Field from json.
func (s *Field) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode Field to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "id":
if err := func() error {
s.ID.Reset()
if err := s.ID.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"id\"")
}
case "name":
if err := func() error {
s.Name.Reset()
if err := s.Name.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"name\"")
}
case "type":
if err := func() error {
s.Type.Reset()
if err := s.Type.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"type\"")
}
case "description":
if err := func() error {
s.Description.Reset()
if err := s.Description.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"description\"")
}
case "options":
if err := func() error {
s.Options.Reset()
if err := s.Options.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"options\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode Field")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *Field) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Field) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s FieldOption) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields implements json.Marshaler.
func (s FieldOption) encodeFields(e *jx.Encoder) {
for k, elem := range s {
e.FieldStart(k)
if len(elem) != 0 {
e.Raw(elem)
}
}
}
// Decode decodes FieldOption from json.
func (s *FieldOption) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode FieldOption to nil")
}
m := s.init()
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
var elem jx.Raw
if err := func() error {
v, err := d.RawAppend(nil)
elem = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrapf(err, "decode field %q", k)
}
m[string(k)] = elem
return nil
}); err != nil {
return errors.Wrap(err, "decode FieldOption")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s FieldOption) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *FieldOption) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode encodes bool as json.
func (o OptBool) Encode(e *jx.Encoder) {
if !o.Set {
return
}
e.Bool(bool(o.Value))
}
// Decode decodes bool from json.
func (o *OptBool) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptBool to nil")
}
o.Set = true
v, err := d.Bool()
if err != nil {
return err
}
o.Value = bool(v)
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptBool) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptBool) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode encodes FieldOption as json.
func (o OptFieldOption) Encode(e *jx.Encoder) {
if !o.Set {
return
}
o.Value.Encode(e)
}
// Decode decodes FieldOption from json.
func (o *OptFieldOption) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptFieldOption to nil")
}
o.Set = true
o.Value = make(FieldOption)
if err := o.Value.Decode(d); err != nil {
return err
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptFieldOption) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptFieldOption) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode encodes []Field as json.
func (o OptNilFieldArray) Encode(e *jx.Encoder) {
if !o.Set {
return
}
if o.Null {
e.Null()
return
}
e.ArrStart()
for _, elem := range o.Value {
elem.Encode(e)
}
e.ArrEnd()
}
// Decode decodes []Field from json.
func (o *OptNilFieldArray) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptNilFieldArray to nil")
}
if d.Next() == jx.Null {
if err := d.Null(); err != nil {
return err
}
var v []Field
o.Value = v
o.Set = true
o.Null = true
return nil
}
o.Set = true
o.Null = false
o.Value = make([]Field, 0)
if err := d.Arr(func(d *jx.Decoder) error {
var elem Field
if err := elem.Decode(d); err != nil {
return err
}
o.Value = append(o.Value, elem)
return nil
}); err != nil {
return err
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptNilFieldArray) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptNilFieldArray) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode encodes string as json.
func (o OptNilString) Encode(e *jx.Encoder) {
if !o.Set {
return
}
if o.Null {
e.Null()
return
}
e.Str(string(o.Value))
}
// Decode decodes string from json.
func (o *OptNilString) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptNilString to nil")
}
if d.Next() == jx.Null {
if err := d.Null(); err != nil {
return err
}
var v string
o.Value = v
o.Set = true
o.Null = true
return nil
}
o.Set = true
o.Null = false
v, err := d.Str()
if err != nil {
return err
}
o.Value = string(v)
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptNilString) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptNilString) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode encodes []View as json.
func (o OptNilViewArray) Encode(e *jx.Encoder) {
if !o.Set {
return
}
if o.Null {
e.Null()
return
}
e.ArrStart()
for _, elem := range o.Value {
elem.Encode(e)
}
e.ArrEnd()
}
// Decode decodes []View from json.
func (o *OptNilViewArray) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptNilViewArray to nil")
}
if d.Next() == jx.Null {
if err := d.Null(); err != nil {
return err
}
var v []View
o.Value = v
o.Set = true
o.Null = true
return nil
}
o.Set = true
o.Null = false
o.Value = make([]View, 0)
if err := d.Arr(func(d *jx.Decoder) error {
var elem View
if err := elem.Decode(d); err != nil {
return err
}
o.Value = append(o.Value, elem)
return nil
}); err != nil {
return err
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptNilViewArray) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptNilViewArray) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode encodes RecordFields as json.
func (o OptRecordFields) Encode(e *jx.Encoder) {
if !o.Set {
return
}
o.Value.Encode(e)
}
// Decode decodes RecordFields from json.
func (o *OptRecordFields) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptRecordFields to nil")
}
o.Set = true
o.Value = make(RecordFields)
if err := o.Value.Decode(d); err != nil {
return err
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptRecordFields) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptRecordFields) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode encodes string as json.
func (o OptString) Encode(e *jx.Encoder) {
if !o.Set {
return
}
e.Str(string(o.Value))
}
// Decode decodes string from json.
func (o *OptString) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptString to nil")
}
o.Set = true
v, err := d.Str()
if err != nil {
return err
}
o.Value = string(v)
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptString) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptString) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *Record) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *Record) encodeFields(e *jx.Encoder) {
{
if s.ID.Set {
e.FieldStart("id")
s.ID.Encode(e)
}
}
{
if s.Fields.Set {
e.FieldStart("fields")
s.Fields.Encode(e)
}
}
{
if s.CreatedTime.Set {
e.FieldStart("createdTime")
s.CreatedTime.Encode(e)
}
}
}
var jsonFieldsNameOfRecord = [3]string{
0: "id",
1: "fields",
2: "createdTime",
}
// Decode decodes Record from json.
func (s *Record) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode Record to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "id":
if err := func() error {
s.ID.Reset()
if err := s.ID.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"id\"")
}
case "fields":
if err := func() error {
s.Fields.Reset()
if err := s.Fields.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"fields\"")
}
case "createdTime":
if err := func() error {
s.CreatedTime.Reset()
if err := s.CreatedTime.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"createdTime\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode Record")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *Record) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Record) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s RecordFields) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields implements json.Marshaler.
func (s RecordFields) encodeFields(e *jx.Encoder) {
for k, elem := range s {
e.FieldStart(k)
if len(elem) != 0 {
e.Raw(elem)
}
}
}
// Decode decodes RecordFields from json.
func (s *RecordFields) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode RecordFields to nil")
}
m := s.init()
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
var elem jx.Raw
if err := func() error {
v, err := d.RawAppend(nil)
elem = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrapf(err, "decode field %q", k)
}
m[string(k)] = elem
return nil
}); err != nil {
return errors.Wrap(err, "decode RecordFields")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s RecordFields) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RecordFields) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *RecordListResponse) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *RecordListResponse) encodeFields(e *jx.Encoder) {
{
if s.Records != nil {
e.FieldStart("records")
e.ArrStart()
for _, elem := range s.Records {
elem.Encode(e)
}
e.ArrEnd()
}
}
{
if s.Offset.Set {
e.FieldStart("offset")
s.Offset.Encode(e)
}
}
}
var jsonFieldsNameOfRecordListResponse = [2]string{
0: "records",
1: "offset",
}
// Decode decodes RecordListResponse from json.
func (s *RecordListResponse) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode RecordListResponse to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "records":
if err := func() error {
s.Records = make([]Record, 0)
if err := d.Arr(func(d *jx.Decoder) error {
var elem Record
if err := elem.Decode(d); err != nil {
return err
}
s.Records = append(s.Records, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"records\"")
}
case "offset":
if err := func() error {
s.Offset.Reset()
if err := s.Offset.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"offset\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode RecordListResponse")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *RecordListResponse) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RecordListResponse) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *Table) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *Table) encodeFields(e *jx.Encoder) {
{
if s.ID.Set {
e.FieldStart("id")
s.ID.Encode(e)
}
}
{
if s.Name.Set {
e.FieldStart("name")
s.Name.Encode(e)
}
}
{
if s.PrimaryFieldId.Set {
e.FieldStart("primaryFieldId")
s.PrimaryFieldId.Encode(e)
}
}
{
if s.Fields.Set {
e.FieldStart("fields")
s.Fields.Encode(e)
}
}
{
if s.Views.Set {
e.FieldStart("views")
s.Views.Encode(e)
}
}
}
var jsonFieldsNameOfTable = [5]string{
0: "id",
1: "name",
2: "primaryFieldId",
3: "fields",
4: "views",
}
// Decode decodes Table from json.
func (s *Table) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode Table to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "id":
if err := func() error {
s.ID.Reset()
if err := s.ID.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"id\"")
}
case "name":
if err := func() error {
s.Name.Reset()
if err := s.Name.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"name\"")
}
case "primaryFieldId":
if err := func() error {
s.PrimaryFieldId.Reset()
if err := s.PrimaryFieldId.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"primaryFieldId\"")
}
case "fields":
if err := func() error {
s.Fields.Reset()
if err := s.Fields.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"fields\"")
}
case "views":
if err := func() error {
s.Views.Reset()
if err := s.Views.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"views\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode Table")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *Table) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Table) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *TableListResponse) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *TableListResponse) encodeFields(e *jx.Encoder) {
{
if s.Tables != nil {
e.FieldStart("tables")
e.ArrStart()
for _, elem := range s.Tables {
elem.Encode(e)
}
e.ArrEnd()
}
}
}
var jsonFieldsNameOfTableListResponse = [1]string{
0: "tables",
}
// Decode decodes TableListResponse from json.
func (s *TableListResponse) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode TableListResponse to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "tables":
if err := func() error {
s.Tables = make([]Table, 0)
if err := d.Arr(func(d *jx.Decoder) error {
var elem Table
if err := elem.Decode(d); err != nil {
return err
}
s.Tables = append(s.Tables, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"tables\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode TableListResponse")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *TableListResponse) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *TableListResponse) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *UpdateRecordsReq) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *UpdateRecordsReq) encodeFields(e *jx.Encoder) {
{
e.FieldStart("records")
e.ArrStart()
for _, elem := range s.Records {
elem.Encode(e)
}
e.ArrEnd()
}
{
if s.Typecast.Set {
e.FieldStart("typecast")
s.Typecast.Encode(e)
}
}
}
var jsonFieldsNameOfUpdateRecordsReq = [2]string{
0: "records",
1: "typecast",
}
// Decode decodes UpdateRecordsReq from json.
func (s *UpdateRecordsReq) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode UpdateRecordsReq to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "records":
requiredBitSet[0] |= 1 << 0
if err := func() error {
s.Records = make([]UpdateRecordsReqRecordsItem, 0)
if err := d.Arr(func(d *jx.Decoder) error {
var elem UpdateRecordsReqRecordsItem
if err := elem.Decode(d); err != nil {
return err
}
s.Records = append(s.Records, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"records\"")
}
case "typecast":
if err := func() error {
s.Typecast.Reset()
if err := s.Typecast.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"typecast\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode UpdateRecordsReq")
}
// Validate required fields.
var failures []validate.FieldError
for i, mask := range [1]uint8{
0b00000001,
} {
if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
// Mask only required fields and check equality to mask using XOR.
//
// If XOR result is not zero, result is not equal to expected, so some fields are missed.
// Bits of fields which would be set are actually bits of missed fields.
missed := bits.OnesCount8(result)
for bitN := 0; bitN < missed; bitN++ {
bitIdx := bits.TrailingZeros8(result)
fieldIdx := i*8 + bitIdx
var name string
if fieldIdx < len(jsonFieldsNameOfUpdateRecordsReq) {
name = jsonFieldsNameOfUpdateRecordsReq[fieldIdx]
} else {
name = strconv.Itoa(fieldIdx)
}
failures = append(failures, validate.FieldError{
Name: name,
Error: validate.ErrFieldRequired,
})
// Reset bit.
result &^= 1 << bitIdx
}
}
}
if len(failures) > 0 {
return &validate.Error{Fields: failures}
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *UpdateRecordsReq) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *UpdateRecordsReq) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *UpdateRecordsReqRecordsItem) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *UpdateRecordsReqRecordsItem) encodeFields(e *jx.Encoder) {
{
if s.ID.Set {
e.FieldStart("id")
s.ID.Encode(e)
}
}
{
if s.Fields.Set {
e.FieldStart("fields")
s.Fields.Encode(e)
}
}
}
var jsonFieldsNameOfUpdateRecordsReqRecordsItem = [2]string{
0: "id",
1: "fields",
}
// Decode decodes UpdateRecordsReqRecordsItem from json.
func (s *UpdateRecordsReqRecordsItem) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode UpdateRecordsReqRecordsItem to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "id":
if err := func() error {
s.ID.Reset()
if err := s.ID.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"id\"")
}
case "fields":
if err := func() error {
s.Fields.Reset()
if err := s.Fields.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"fields\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode UpdateRecordsReqRecordsItem")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *UpdateRecordsReqRecordsItem) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *UpdateRecordsReqRecordsItem) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *UpdateRecordsResponse) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *UpdateRecordsResponse) encodeFields(e *jx.Encoder) {
{
if s.Records != nil {
e.FieldStart("records")
e.ArrStart()
for _, elem := range s.Records {
elem.Encode(e)
}
e.ArrEnd()
}
}
}
var jsonFieldsNameOfUpdateRecordsResponse = [1]string{
0: "records",
}
// Decode decodes UpdateRecordsResponse from json.
func (s *UpdateRecordsResponse) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode UpdateRecordsResponse to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "records":
if err := func() error {
s.Records = make([]Record, 0)
if err := d.Arr(func(d *jx.Decoder) error {
var elem Record
if err := elem.Decode(d); err != nil {
return err
}
s.Records = append(s.Records, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"records\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode UpdateRecordsResponse")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *UpdateRecordsResponse) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *UpdateRecordsResponse) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *UpdateTableReq) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *UpdateTableReq) encodeFields(e *jx.Encoder) {
{
if s.Name.Set {
e.FieldStart("name")
s.Name.Encode(e)
}
}
{
if s.Description.Set {
e.FieldStart("description")
s.Description.Encode(e)
}
}
}
var jsonFieldsNameOfUpdateTableReq = [2]string{
0: "name",
1: "description",
}
// Decode decodes UpdateTableReq from json.
func (s *UpdateTableReq) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode UpdateTableReq to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "name":
if err := func() error {
s.Name.Reset()
if err := s.Name.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"name\"")
}
case "description":
if err := func() error {
s.Description.Reset()
if err := s.Description.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"description\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode UpdateTableReq")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *UpdateTableReq) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *UpdateTableReq) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *View) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *View) encodeFields(e *jx.Encoder) {
{
if s.ID.Set {
e.FieldStart("id")
s.ID.Encode(e)
}
}
{
if s.Name.Set {
e.FieldStart("name")
s.Name.Encode(e)
}
}
{
if s.Type.Set {
e.FieldStart("type")
s.Type.Encode(e)
}
}
}
var jsonFieldsNameOfView = [3]string{
0: "id",
1: "name",
2: "type",
}
// Decode decodes View from json.
func (s *View) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode View to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "id":
if err := func() error {
s.ID.Reset()
if err := s.ID.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"id\"")
}
case "name":
if err := func() error {
s.Name.Reset()
if err := s.Name.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"name\"")
}
case "type":
if err := func() error {
s.Type.Reset()
if err := s.Type.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"type\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode View")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *View) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *View) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
