4026 lines
87 KiB
Go
4026 lines
87 KiB
Go
// Code generated by ogen, DO NOT EDIT.
|
|
|
|
package ogent
|
|
|
|
import (
|
|
"math/bits"
|
|
"strconv"
|
|
"time"
|
|
|
|
"github.com/go-faster/errors"
|
|
"github.com/go-faster/jx"
|
|
|
|
"github.com/ogen-go/ogen/json"
|
|
"github.com/ogen-go/ogen/validate"
|
|
)
|
|
|
|
// Encode implements json.Marshaler.
|
|
func (s *CardCreate) Encode(e *jx.Encoder) {
|
|
e.ObjStart()
|
|
s.encodeFields(e)
|
|
e.ObjEnd()
|
|
}
|
|
|
|
// encodeFields encodes fields.
|
|
func (s *CardCreate) encodeFields(e *jx.Encoder) {
|
|
{
|
|
|
|
e.FieldStart("id")
|
|
e.Int(s.ID)
|
|
}
|
|
{
|
|
if s.Card.Set {
|
|
e.FieldStart("card")
|
|
s.Card.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Status.Set {
|
|
e.FieldStart("status")
|
|
s.Status.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Cp.Set {
|
|
e.FieldStart("cp")
|
|
s.Cp.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.URL.Set {
|
|
e.FieldStart("url")
|
|
s.URL.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.CreatedAt.Set {
|
|
e.FieldStart("created_at")
|
|
s.CreatedAt.Encode(e, json.EncodeDateTime)
|
|
}
|
|
}
|
|
}
|
|
|
|
var jsonFieldsNameOfCardCreate = [6]string{
|
|
0: "id",
|
|
1: "card",
|
|
2: "status",
|
|
3: "cp",
|
|
4: "url",
|
|
5: "created_at",
|
|
}
|
|
|
|
// Decode decodes CardCreate from json.
|
|
func (s *CardCreate) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode CardCreate to nil")
|
|
}
|
|
var requiredBitSet [1]uint8
|
|
|
|
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
|
|
switch string(k) {
|
|
case "id":
|
|
requiredBitSet[0] |= 1 << 0
|
|
if err := func() error {
|
|
v, err := d.Int()
|
|
s.ID = int(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"id\"")
|
|
}
|
|
case "card":
|
|
if err := func() error {
|
|
s.Card.Reset()
|
|
if err := s.Card.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"card\"")
|
|
}
|
|
case "status":
|
|
if err := func() error {
|
|
s.Status.Reset()
|
|
if err := s.Status.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"status\"")
|
|
}
|
|
case "cp":
|
|
if err := func() error {
|
|
s.Cp.Reset()
|
|
if err := s.Cp.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"cp\"")
|
|
}
|
|
case "url":
|
|
if err := func() error {
|
|
s.URL.Reset()
|
|
if err := s.URL.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"url\"")
|
|
}
|
|
case "created_at":
|
|
if err := func() error {
|
|
s.CreatedAt.Reset()
|
|
if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"created_at\"")
|
|
}
|
|
default:
|
|
return d.Skip()
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
return errors.Wrap(err, "decode CardCreate")
|
|
}
|
|
// 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(jsonFieldsNameOfCardCreate) {
|
|
name = jsonFieldsNameOfCardCreate[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 *CardCreate) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *CardCreate) UnmarshalJSON(data []byte) error {
|
|
d := jx.DecodeBytes(data)
|
|
return s.Decode(d)
|
|
}
|
|
|
|
// Encode implements json.Marshaler.
|
|
func (s *CardList) Encode(e *jx.Encoder) {
|
|
e.ObjStart()
|
|
s.encodeFields(e)
|
|
e.ObjEnd()
|
|
}
|
|
|
|
// encodeFields encodes fields.
|
|
func (s *CardList) encodeFields(e *jx.Encoder) {
|
|
{
|
|
|
|
e.FieldStart("id")
|
|
e.Int(s.ID)
|
|
}
|
|
{
|
|
if s.Card.Set {
|
|
e.FieldStart("card")
|
|
s.Card.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Status.Set {
|
|
e.FieldStart("status")
|
|
s.Status.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Cp.Set {
|
|
e.FieldStart("cp")
|
|
s.Cp.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.URL.Set {
|
|
e.FieldStart("url")
|
|
s.URL.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.CreatedAt.Set {
|
|
e.FieldStart("created_at")
|
|
s.CreatedAt.Encode(e, json.EncodeDateTime)
|
|
}
|
|
}
|
|
}
|
|
|
|
var jsonFieldsNameOfCardList = [6]string{
|
|
0: "id",
|
|
1: "card",
|
|
2: "status",
|
|
3: "cp",
|
|
4: "url",
|
|
5: "created_at",
|
|
}
|
|
|
|
// Decode decodes CardList from json.
|
|
func (s *CardList) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode CardList to nil")
|
|
}
|
|
var requiredBitSet [1]uint8
|
|
|
|
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
|
|
switch string(k) {
|
|
case "id":
|
|
requiredBitSet[0] |= 1 << 0
|
|
if err := func() error {
|
|
v, err := d.Int()
|
|
s.ID = int(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"id\"")
|
|
}
|
|
case "card":
|
|
if err := func() error {
|
|
s.Card.Reset()
|
|
if err := s.Card.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"card\"")
|
|
}
|
|
case "status":
|
|
if err := func() error {
|
|
s.Status.Reset()
|
|
if err := s.Status.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"status\"")
|
|
}
|
|
case "cp":
|
|
if err := func() error {
|
|
s.Cp.Reset()
|
|
if err := s.Cp.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"cp\"")
|
|
}
|
|
case "url":
|
|
if err := func() error {
|
|
s.URL.Reset()
|
|
if err := s.URL.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"url\"")
|
|
}
|
|
case "created_at":
|
|
if err := func() error {
|
|
s.CreatedAt.Reset()
|
|
if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"created_at\"")
|
|
}
|
|
default:
|
|
return d.Skip()
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
return errors.Wrap(err, "decode CardList")
|
|
}
|
|
// 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(jsonFieldsNameOfCardList) {
|
|
name = jsonFieldsNameOfCardList[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 *CardList) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *CardList) UnmarshalJSON(data []byte) error {
|
|
d := jx.DecodeBytes(data)
|
|
return s.Decode(d)
|
|
}
|
|
|
|
// Encode implements json.Marshaler.
|
|
func (s *CardOwnerRead) Encode(e *jx.Encoder) {
|
|
e.ObjStart()
|
|
s.encodeFields(e)
|
|
e.ObjEnd()
|
|
}
|
|
|
|
// encodeFields encodes fields.
|
|
func (s *CardOwnerRead) encodeFields(e *jx.Encoder) {
|
|
{
|
|
|
|
e.FieldStart("id")
|
|
e.Int(s.ID)
|
|
}
|
|
{
|
|
|
|
e.FieldStart("username")
|
|
e.Str(s.Username)
|
|
}
|
|
{
|
|
if s.CreatedAt.Set {
|
|
e.FieldStart("created_at")
|
|
s.CreatedAt.Encode(e, json.EncodeDateTime)
|
|
}
|
|
}
|
|
{
|
|
if s.UpdatedAt.Set {
|
|
e.FieldStart("updated_at")
|
|
s.UpdatedAt.Encode(e, json.EncodeDateTime)
|
|
}
|
|
}
|
|
{
|
|
if s.Next.Set {
|
|
e.FieldStart("next")
|
|
s.Next.Encode(e)
|
|
}
|
|
}
|
|
}
|
|
|
|
var jsonFieldsNameOfCardOwnerRead = [5]string{
|
|
0: "id",
|
|
1: "username",
|
|
2: "created_at",
|
|
3: "updated_at",
|
|
4: "next",
|
|
}
|
|
|
|
// Decode decodes CardOwnerRead from json.
|
|
func (s *CardOwnerRead) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode CardOwnerRead to nil")
|
|
}
|
|
var requiredBitSet [1]uint8
|
|
|
|
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
|
|
switch string(k) {
|
|
case "id":
|
|
requiredBitSet[0] |= 1 << 0
|
|
if err := func() error {
|
|
v, err := d.Int()
|
|
s.ID = int(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"id\"")
|
|
}
|
|
case "username":
|
|
requiredBitSet[0] |= 1 << 1
|
|
if err := func() error {
|
|
v, err := d.Str()
|
|
s.Username = string(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"username\"")
|
|
}
|
|
case "created_at":
|
|
if err := func() error {
|
|
s.CreatedAt.Reset()
|
|
if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"created_at\"")
|
|
}
|
|
case "updated_at":
|
|
if err := func() error {
|
|
s.UpdatedAt.Reset()
|
|
if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"updated_at\"")
|
|
}
|
|
case "next":
|
|
if err := func() error {
|
|
s.Next.Reset()
|
|
if err := s.Next.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"next\"")
|
|
}
|
|
default:
|
|
return d.Skip()
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
return errors.Wrap(err, "decode CardOwnerRead")
|
|
}
|
|
// Validate required fields.
|
|
var failures []validate.FieldError
|
|
for i, mask := range [1]uint8{
|
|
0b00000011,
|
|
} {
|
|
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(jsonFieldsNameOfCardOwnerRead) {
|
|
name = jsonFieldsNameOfCardOwnerRead[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 *CardOwnerRead) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *CardOwnerRead) UnmarshalJSON(data []byte) error {
|
|
d := jx.DecodeBytes(data)
|
|
return s.Decode(d)
|
|
}
|
|
|
|
// Encode implements json.Marshaler.
|
|
func (s *CardRead) Encode(e *jx.Encoder) {
|
|
e.ObjStart()
|
|
s.encodeFields(e)
|
|
e.ObjEnd()
|
|
}
|
|
|
|
// encodeFields encodes fields.
|
|
func (s *CardRead) encodeFields(e *jx.Encoder) {
|
|
{
|
|
|
|
e.FieldStart("id")
|
|
e.Int(s.ID)
|
|
}
|
|
{
|
|
if s.Card.Set {
|
|
e.FieldStart("card")
|
|
s.Card.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Status.Set {
|
|
e.FieldStart("status")
|
|
s.Status.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Cp.Set {
|
|
e.FieldStart("cp")
|
|
s.Cp.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.URL.Set {
|
|
e.FieldStart("url")
|
|
s.URL.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.CreatedAt.Set {
|
|
e.FieldStart("created_at")
|
|
s.CreatedAt.Encode(e, json.EncodeDateTime)
|
|
}
|
|
}
|
|
}
|
|
|
|
var jsonFieldsNameOfCardRead = [6]string{
|
|
0: "id",
|
|
1: "card",
|
|
2: "status",
|
|
3: "cp",
|
|
4: "url",
|
|
5: "created_at",
|
|
}
|
|
|
|
// Decode decodes CardRead from json.
|
|
func (s *CardRead) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode CardRead to nil")
|
|
}
|
|
var requiredBitSet [1]uint8
|
|
|
|
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
|
|
switch string(k) {
|
|
case "id":
|
|
requiredBitSet[0] |= 1 << 0
|
|
if err := func() error {
|
|
v, err := d.Int()
|
|
s.ID = int(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"id\"")
|
|
}
|
|
case "card":
|
|
if err := func() error {
|
|
s.Card.Reset()
|
|
if err := s.Card.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"card\"")
|
|
}
|
|
case "status":
|
|
if err := func() error {
|
|
s.Status.Reset()
|
|
if err := s.Status.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"status\"")
|
|
}
|
|
case "cp":
|
|
if err := func() error {
|
|
s.Cp.Reset()
|
|
if err := s.Cp.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"cp\"")
|
|
}
|
|
case "url":
|
|
if err := func() error {
|
|
s.URL.Reset()
|
|
if err := s.URL.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"url\"")
|
|
}
|
|
case "created_at":
|
|
if err := func() error {
|
|
s.CreatedAt.Reset()
|
|
if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"created_at\"")
|
|
}
|
|
default:
|
|
return d.Skip()
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
return errors.Wrap(err, "decode CardRead")
|
|
}
|
|
// 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(jsonFieldsNameOfCardRead) {
|
|
name = jsonFieldsNameOfCardRead[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 *CardRead) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *CardRead) UnmarshalJSON(data []byte) error {
|
|
d := jx.DecodeBytes(data)
|
|
return s.Decode(d)
|
|
}
|
|
|
|
// Encode implements json.Marshaler.
|
|
func (s *CardUpdate) Encode(e *jx.Encoder) {
|
|
e.ObjStart()
|
|
s.encodeFields(e)
|
|
e.ObjEnd()
|
|
}
|
|
|
|
// encodeFields encodes fields.
|
|
func (s *CardUpdate) encodeFields(e *jx.Encoder) {
|
|
{
|
|
|
|
e.FieldStart("id")
|
|
e.Int(s.ID)
|
|
}
|
|
{
|
|
if s.Card.Set {
|
|
e.FieldStart("card")
|
|
s.Card.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Status.Set {
|
|
e.FieldStart("status")
|
|
s.Status.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Cp.Set {
|
|
e.FieldStart("cp")
|
|
s.Cp.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.URL.Set {
|
|
e.FieldStart("url")
|
|
s.URL.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.CreatedAt.Set {
|
|
e.FieldStart("created_at")
|
|
s.CreatedAt.Encode(e, json.EncodeDateTime)
|
|
}
|
|
}
|
|
}
|
|
|
|
var jsonFieldsNameOfCardUpdate = [6]string{
|
|
0: "id",
|
|
1: "card",
|
|
2: "status",
|
|
3: "cp",
|
|
4: "url",
|
|
5: "created_at",
|
|
}
|
|
|
|
// Decode decodes CardUpdate from json.
|
|
func (s *CardUpdate) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode CardUpdate to nil")
|
|
}
|
|
var requiredBitSet [1]uint8
|
|
|
|
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
|
|
switch string(k) {
|
|
case "id":
|
|
requiredBitSet[0] |= 1 << 0
|
|
if err := func() error {
|
|
v, err := d.Int()
|
|
s.ID = int(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"id\"")
|
|
}
|
|
case "card":
|
|
if err := func() error {
|
|
s.Card.Reset()
|
|
if err := s.Card.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"card\"")
|
|
}
|
|
case "status":
|
|
if err := func() error {
|
|
s.Status.Reset()
|
|
if err := s.Status.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"status\"")
|
|
}
|
|
case "cp":
|
|
if err := func() error {
|
|
s.Cp.Reset()
|
|
if err := s.Cp.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"cp\"")
|
|
}
|
|
case "url":
|
|
if err := func() error {
|
|
s.URL.Reset()
|
|
if err := s.URL.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"url\"")
|
|
}
|
|
case "created_at":
|
|
if err := func() error {
|
|
s.CreatedAt.Reset()
|
|
if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"created_at\"")
|
|
}
|
|
default:
|
|
return d.Skip()
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
return errors.Wrap(err, "decode CardUpdate")
|
|
}
|
|
// 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(jsonFieldsNameOfCardUpdate) {
|
|
name = jsonFieldsNameOfCardUpdate[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 *CardUpdate) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *CardUpdate) UnmarshalJSON(data []byte) error {
|
|
d := jx.DecodeBytes(data)
|
|
return s.Decode(d)
|
|
}
|
|
|
|
// Encode implements json.Marshaler.
|
|
func (s *CreateCardReq) Encode(e *jx.Encoder) {
|
|
e.ObjStart()
|
|
s.encodeFields(e)
|
|
e.ObjEnd()
|
|
}
|
|
|
|
// encodeFields encodes fields.
|
|
func (s *CreateCardReq) encodeFields(e *jx.Encoder) {
|
|
{
|
|
if s.Card.Set {
|
|
e.FieldStart("card")
|
|
s.Card.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Status.Set {
|
|
e.FieldStart("status")
|
|
s.Status.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Cp.Set {
|
|
e.FieldStart("cp")
|
|
s.Cp.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.URL.Set {
|
|
e.FieldStart("url")
|
|
s.URL.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.CreatedAt.Set {
|
|
e.FieldStart("created_at")
|
|
s.CreatedAt.Encode(e, json.EncodeDateTime)
|
|
}
|
|
}
|
|
{
|
|
|
|
e.FieldStart("owner")
|
|
e.Int(s.Owner)
|
|
}
|
|
}
|
|
|
|
var jsonFieldsNameOfCreateCardReq = [6]string{
|
|
0: "card",
|
|
1: "status",
|
|
2: "cp",
|
|
3: "url",
|
|
4: "created_at",
|
|
5: "owner",
|
|
}
|
|
|
|
// Decode decodes CreateCardReq from json.
|
|
func (s *CreateCardReq) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode CreateCardReq to nil")
|
|
}
|
|
var requiredBitSet [1]uint8
|
|
|
|
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
|
|
switch string(k) {
|
|
case "card":
|
|
if err := func() error {
|
|
s.Card.Reset()
|
|
if err := s.Card.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"card\"")
|
|
}
|
|
case "status":
|
|
if err := func() error {
|
|
s.Status.Reset()
|
|
if err := s.Status.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"status\"")
|
|
}
|
|
case "cp":
|
|
if err := func() error {
|
|
s.Cp.Reset()
|
|
if err := s.Cp.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"cp\"")
|
|
}
|
|
case "url":
|
|
if err := func() error {
|
|
s.URL.Reset()
|
|
if err := s.URL.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"url\"")
|
|
}
|
|
case "created_at":
|
|
if err := func() error {
|
|
s.CreatedAt.Reset()
|
|
if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"created_at\"")
|
|
}
|
|
case "owner":
|
|
requiredBitSet[0] |= 1 << 5
|
|
if err := func() error {
|
|
v, err := d.Int()
|
|
s.Owner = int(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"owner\"")
|
|
}
|
|
default:
|
|
return d.Skip()
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
return errors.Wrap(err, "decode CreateCardReq")
|
|
}
|
|
// Validate required fields.
|
|
var failures []validate.FieldError
|
|
for i, mask := range [1]uint8{
|
|
0b00100000,
|
|
} {
|
|
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(jsonFieldsNameOfCreateCardReq) {
|
|
name = jsonFieldsNameOfCreateCardReq[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 *CreateCardReq) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *CreateCardReq) UnmarshalJSON(data []byte) error {
|
|
d := jx.DecodeBytes(data)
|
|
return s.Decode(d)
|
|
}
|
|
|
|
// Encode implements json.Marshaler.
|
|
func (s *CreateGroupReq) Encode(e *jx.Encoder) {
|
|
e.ObjStart()
|
|
s.encodeFields(e)
|
|
e.ObjEnd()
|
|
}
|
|
|
|
// encodeFields encodes fields.
|
|
func (s *CreateGroupReq) encodeFields(e *jx.Encoder) {
|
|
{
|
|
|
|
e.FieldStart("name")
|
|
e.Str(s.Name)
|
|
}
|
|
{
|
|
if s.Users != nil {
|
|
e.FieldStart("users")
|
|
e.ArrStart()
|
|
for _, elem := range s.Users {
|
|
e.Int(elem)
|
|
}
|
|
e.ArrEnd()
|
|
}
|
|
}
|
|
}
|
|
|
|
var jsonFieldsNameOfCreateGroupReq = [2]string{
|
|
0: "name",
|
|
1: "users",
|
|
}
|
|
|
|
// Decode decodes CreateGroupReq from json.
|
|
func (s *CreateGroupReq) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode CreateGroupReq 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 "users":
|
|
if err := func() error {
|
|
s.Users = make([]int, 0)
|
|
if err := d.Arr(func(d *jx.Decoder) error {
|
|
var elem int
|
|
v, err := d.Int()
|
|
elem = int(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
s.Users = append(s.Users, elem)
|
|
return nil
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"users\"")
|
|
}
|
|
default:
|
|
return d.Skip()
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
return errors.Wrap(err, "decode CreateGroupReq")
|
|
}
|
|
// 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(jsonFieldsNameOfCreateGroupReq) {
|
|
name = jsonFieldsNameOfCreateGroupReq[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 *CreateGroupReq) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *CreateGroupReq) UnmarshalJSON(data []byte) error {
|
|
d := jx.DecodeBytes(data)
|
|
return s.Decode(d)
|
|
}
|
|
|
|
// Encode implements json.Marshaler.
|
|
func (s *CreateUserReq) Encode(e *jx.Encoder) {
|
|
e.ObjStart()
|
|
s.encodeFields(e)
|
|
e.ObjEnd()
|
|
}
|
|
|
|
// encodeFields encodes fields.
|
|
func (s *CreateUserReq) encodeFields(e *jx.Encoder) {
|
|
{
|
|
|
|
e.FieldStart("username")
|
|
e.Str(s.Username)
|
|
}
|
|
{
|
|
if s.CreatedAt.Set {
|
|
e.FieldStart("created_at")
|
|
s.CreatedAt.Encode(e, json.EncodeDateTime)
|
|
}
|
|
}
|
|
{
|
|
if s.UpdatedAt.Set {
|
|
e.FieldStart("updated_at")
|
|
s.UpdatedAt.Encode(e, json.EncodeDateTime)
|
|
}
|
|
}
|
|
{
|
|
if s.Next.Set {
|
|
e.FieldStart("next")
|
|
s.Next.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Card != nil {
|
|
e.FieldStart("card")
|
|
e.ArrStart()
|
|
for _, elem := range s.Card {
|
|
e.Int(elem)
|
|
}
|
|
e.ArrEnd()
|
|
}
|
|
}
|
|
}
|
|
|
|
var jsonFieldsNameOfCreateUserReq = [5]string{
|
|
0: "username",
|
|
1: "created_at",
|
|
2: "updated_at",
|
|
3: "next",
|
|
4: "card",
|
|
}
|
|
|
|
// Decode decodes CreateUserReq from json.
|
|
func (s *CreateUserReq) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode CreateUserReq to nil")
|
|
}
|
|
var requiredBitSet [1]uint8
|
|
|
|
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
|
|
switch string(k) {
|
|
case "username":
|
|
requiredBitSet[0] |= 1 << 0
|
|
if err := func() error {
|
|
v, err := d.Str()
|
|
s.Username = string(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"username\"")
|
|
}
|
|
case "created_at":
|
|
if err := func() error {
|
|
s.CreatedAt.Reset()
|
|
if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"created_at\"")
|
|
}
|
|
case "updated_at":
|
|
if err := func() error {
|
|
s.UpdatedAt.Reset()
|
|
if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"updated_at\"")
|
|
}
|
|
case "next":
|
|
if err := func() error {
|
|
s.Next.Reset()
|
|
if err := s.Next.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"next\"")
|
|
}
|
|
case "card":
|
|
if err := func() error {
|
|
s.Card = make([]int, 0)
|
|
if err := d.Arr(func(d *jx.Decoder) error {
|
|
var elem int
|
|
v, err := d.Int()
|
|
elem = int(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
s.Card = append(s.Card, elem)
|
|
return nil
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"card\"")
|
|
}
|
|
default:
|
|
return d.Skip()
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
return errors.Wrap(err, "decode CreateUserReq")
|
|
}
|
|
// 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(jsonFieldsNameOfCreateUserReq) {
|
|
name = jsonFieldsNameOfCreateUserReq[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 *CreateUserReq) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *CreateUserReq) UnmarshalJSON(data []byte) error {
|
|
d := jx.DecodeBytes(data)
|
|
return s.Decode(d)
|
|
}
|
|
|
|
// Encode implements json.Marshaler.
|
|
func (s *GroupCreate) Encode(e *jx.Encoder) {
|
|
e.ObjStart()
|
|
s.encodeFields(e)
|
|
e.ObjEnd()
|
|
}
|
|
|
|
// encodeFields encodes fields.
|
|
func (s *GroupCreate) encodeFields(e *jx.Encoder) {
|
|
{
|
|
|
|
e.FieldStart("id")
|
|
e.Int(s.ID)
|
|
}
|
|
{
|
|
|
|
e.FieldStart("name")
|
|
e.Str(s.Name)
|
|
}
|
|
}
|
|
|
|
var jsonFieldsNameOfGroupCreate = [2]string{
|
|
0: "id",
|
|
1: "name",
|
|
}
|
|
|
|
// Decode decodes GroupCreate from json.
|
|
func (s *GroupCreate) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode GroupCreate to nil")
|
|
}
|
|
var requiredBitSet [1]uint8
|
|
|
|
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
|
|
switch string(k) {
|
|
case "id":
|
|
requiredBitSet[0] |= 1 << 0
|
|
if err := func() error {
|
|
v, err := d.Int()
|
|
s.ID = int(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"id\"")
|
|
}
|
|
case "name":
|
|
requiredBitSet[0] |= 1 << 1
|
|
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\"")
|
|
}
|
|
default:
|
|
return d.Skip()
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
return errors.Wrap(err, "decode GroupCreate")
|
|
}
|
|
// Validate required fields.
|
|
var failures []validate.FieldError
|
|
for i, mask := range [1]uint8{
|
|
0b00000011,
|
|
} {
|
|
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(jsonFieldsNameOfGroupCreate) {
|
|
name = jsonFieldsNameOfGroupCreate[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 *GroupCreate) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *GroupCreate) UnmarshalJSON(data []byte) error {
|
|
d := jx.DecodeBytes(data)
|
|
return s.Decode(d)
|
|
}
|
|
|
|
// Encode implements json.Marshaler.
|
|
func (s *GroupList) Encode(e *jx.Encoder) {
|
|
e.ObjStart()
|
|
s.encodeFields(e)
|
|
e.ObjEnd()
|
|
}
|
|
|
|
// encodeFields encodes fields.
|
|
func (s *GroupList) encodeFields(e *jx.Encoder) {
|
|
{
|
|
|
|
e.FieldStart("id")
|
|
e.Int(s.ID)
|
|
}
|
|
{
|
|
|
|
e.FieldStart("name")
|
|
e.Str(s.Name)
|
|
}
|
|
}
|
|
|
|
var jsonFieldsNameOfGroupList = [2]string{
|
|
0: "id",
|
|
1: "name",
|
|
}
|
|
|
|
// Decode decodes GroupList from json.
|
|
func (s *GroupList) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode GroupList to nil")
|
|
}
|
|
var requiredBitSet [1]uint8
|
|
|
|
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
|
|
switch string(k) {
|
|
case "id":
|
|
requiredBitSet[0] |= 1 << 0
|
|
if err := func() error {
|
|
v, err := d.Int()
|
|
s.ID = int(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"id\"")
|
|
}
|
|
case "name":
|
|
requiredBitSet[0] |= 1 << 1
|
|
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\"")
|
|
}
|
|
default:
|
|
return d.Skip()
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
return errors.Wrap(err, "decode GroupList")
|
|
}
|
|
// Validate required fields.
|
|
var failures []validate.FieldError
|
|
for i, mask := range [1]uint8{
|
|
0b00000011,
|
|
} {
|
|
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(jsonFieldsNameOfGroupList) {
|
|
name = jsonFieldsNameOfGroupList[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 *GroupList) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *GroupList) UnmarshalJSON(data []byte) error {
|
|
d := jx.DecodeBytes(data)
|
|
return s.Decode(d)
|
|
}
|
|
|
|
// Encode implements json.Marshaler.
|
|
func (s *GroupRead) Encode(e *jx.Encoder) {
|
|
e.ObjStart()
|
|
s.encodeFields(e)
|
|
e.ObjEnd()
|
|
}
|
|
|
|
// encodeFields encodes fields.
|
|
func (s *GroupRead) encodeFields(e *jx.Encoder) {
|
|
{
|
|
|
|
e.FieldStart("id")
|
|
e.Int(s.ID)
|
|
}
|
|
{
|
|
|
|
e.FieldStart("name")
|
|
e.Str(s.Name)
|
|
}
|
|
}
|
|
|
|
var jsonFieldsNameOfGroupRead = [2]string{
|
|
0: "id",
|
|
1: "name",
|
|
}
|
|
|
|
// Decode decodes GroupRead from json.
|
|
func (s *GroupRead) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode GroupRead to nil")
|
|
}
|
|
var requiredBitSet [1]uint8
|
|
|
|
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
|
|
switch string(k) {
|
|
case "id":
|
|
requiredBitSet[0] |= 1 << 0
|
|
if err := func() error {
|
|
v, err := d.Int()
|
|
s.ID = int(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"id\"")
|
|
}
|
|
case "name":
|
|
requiredBitSet[0] |= 1 << 1
|
|
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\"")
|
|
}
|
|
default:
|
|
return d.Skip()
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
return errors.Wrap(err, "decode GroupRead")
|
|
}
|
|
// Validate required fields.
|
|
var failures []validate.FieldError
|
|
for i, mask := range [1]uint8{
|
|
0b00000011,
|
|
} {
|
|
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(jsonFieldsNameOfGroupRead) {
|
|
name = jsonFieldsNameOfGroupRead[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 *GroupRead) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *GroupRead) UnmarshalJSON(data []byte) error {
|
|
d := jx.DecodeBytes(data)
|
|
return s.Decode(d)
|
|
}
|
|
|
|
// Encode implements json.Marshaler.
|
|
func (s *GroupUpdate) Encode(e *jx.Encoder) {
|
|
e.ObjStart()
|
|
s.encodeFields(e)
|
|
e.ObjEnd()
|
|
}
|
|
|
|
// encodeFields encodes fields.
|
|
func (s *GroupUpdate) encodeFields(e *jx.Encoder) {
|
|
{
|
|
|
|
e.FieldStart("id")
|
|
e.Int(s.ID)
|
|
}
|
|
{
|
|
|
|
e.FieldStart("name")
|
|
e.Str(s.Name)
|
|
}
|
|
}
|
|
|
|
var jsonFieldsNameOfGroupUpdate = [2]string{
|
|
0: "id",
|
|
1: "name",
|
|
}
|
|
|
|
// Decode decodes GroupUpdate from json.
|
|
func (s *GroupUpdate) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode GroupUpdate to nil")
|
|
}
|
|
var requiredBitSet [1]uint8
|
|
|
|
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
|
|
switch string(k) {
|
|
case "id":
|
|
requiredBitSet[0] |= 1 << 0
|
|
if err := func() error {
|
|
v, err := d.Int()
|
|
s.ID = int(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"id\"")
|
|
}
|
|
case "name":
|
|
requiredBitSet[0] |= 1 << 1
|
|
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\"")
|
|
}
|
|
default:
|
|
return d.Skip()
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
return errors.Wrap(err, "decode GroupUpdate")
|
|
}
|
|
// Validate required fields.
|
|
var failures []validate.FieldError
|
|
for i, mask := range [1]uint8{
|
|
0b00000011,
|
|
} {
|
|
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(jsonFieldsNameOfGroupUpdate) {
|
|
name = jsonFieldsNameOfGroupUpdate[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 *GroupUpdate) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *GroupUpdate) UnmarshalJSON(data []byte) error {
|
|
d := jx.DecodeBytes(data)
|
|
return s.Decode(d)
|
|
}
|
|
|
|
// Encode implements json.Marshaler.
|
|
func (s *GroupUsersList) Encode(e *jx.Encoder) {
|
|
e.ObjStart()
|
|
s.encodeFields(e)
|
|
e.ObjEnd()
|
|
}
|
|
|
|
// encodeFields encodes fields.
|
|
func (s *GroupUsersList) encodeFields(e *jx.Encoder) {
|
|
{
|
|
|
|
e.FieldStart("id")
|
|
e.Int(s.ID)
|
|
}
|
|
{
|
|
|
|
e.FieldStart("username")
|
|
e.Str(s.Username)
|
|
}
|
|
{
|
|
if s.CreatedAt.Set {
|
|
e.FieldStart("created_at")
|
|
s.CreatedAt.Encode(e, json.EncodeDateTime)
|
|
}
|
|
}
|
|
{
|
|
if s.UpdatedAt.Set {
|
|
e.FieldStart("updated_at")
|
|
s.UpdatedAt.Encode(e, json.EncodeDateTime)
|
|
}
|
|
}
|
|
{
|
|
if s.Next.Set {
|
|
e.FieldStart("next")
|
|
s.Next.Encode(e)
|
|
}
|
|
}
|
|
}
|
|
|
|
var jsonFieldsNameOfGroupUsersList = [5]string{
|
|
0: "id",
|
|
1: "username",
|
|
2: "created_at",
|
|
3: "updated_at",
|
|
4: "next",
|
|
}
|
|
|
|
// Decode decodes GroupUsersList from json.
|
|
func (s *GroupUsersList) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode GroupUsersList to nil")
|
|
}
|
|
var requiredBitSet [1]uint8
|
|
|
|
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
|
|
switch string(k) {
|
|
case "id":
|
|
requiredBitSet[0] |= 1 << 0
|
|
if err := func() error {
|
|
v, err := d.Int()
|
|
s.ID = int(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"id\"")
|
|
}
|
|
case "username":
|
|
requiredBitSet[0] |= 1 << 1
|
|
if err := func() error {
|
|
v, err := d.Str()
|
|
s.Username = string(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"username\"")
|
|
}
|
|
case "created_at":
|
|
if err := func() error {
|
|
s.CreatedAt.Reset()
|
|
if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"created_at\"")
|
|
}
|
|
case "updated_at":
|
|
if err := func() error {
|
|
s.UpdatedAt.Reset()
|
|
if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"updated_at\"")
|
|
}
|
|
case "next":
|
|
if err := func() error {
|
|
s.Next.Reset()
|
|
if err := s.Next.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"next\"")
|
|
}
|
|
default:
|
|
return d.Skip()
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
return errors.Wrap(err, "decode GroupUsersList")
|
|
}
|
|
// Validate required fields.
|
|
var failures []validate.FieldError
|
|
for i, mask := range [1]uint8{
|
|
0b00000011,
|
|
} {
|
|
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(jsonFieldsNameOfGroupUsersList) {
|
|
name = jsonFieldsNameOfGroupUsersList[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 *GroupUsersList) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *GroupUsersList) UnmarshalJSON(data []byte) error {
|
|
d := jx.DecodeBytes(data)
|
|
return s.Decode(d)
|
|
}
|
|
|
|
// Encode encodes ListCardOKApplicationJSON as json.
|
|
func (s ListCardOKApplicationJSON) Encode(e *jx.Encoder) {
|
|
unwrapped := []CardList(s)
|
|
|
|
e.ArrStart()
|
|
for _, elem := range unwrapped {
|
|
elem.Encode(e)
|
|
}
|
|
e.ArrEnd()
|
|
}
|
|
|
|
// Decode decodes ListCardOKApplicationJSON from json.
|
|
func (s *ListCardOKApplicationJSON) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode ListCardOKApplicationJSON to nil")
|
|
}
|
|
var unwrapped []CardList
|
|
if err := func() error {
|
|
unwrapped = make([]CardList, 0)
|
|
if err := d.Arr(func(d *jx.Decoder) error {
|
|
var elem CardList
|
|
if err := elem.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
unwrapped = append(unwrapped, elem)
|
|
return nil
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "alias")
|
|
}
|
|
*s = ListCardOKApplicationJSON(unwrapped)
|
|
return nil
|
|
}
|
|
|
|
// MarshalJSON implements stdjson.Marshaler.
|
|
func (s ListCardOKApplicationJSON) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *ListCardOKApplicationJSON) UnmarshalJSON(data []byte) error {
|
|
d := jx.DecodeBytes(data)
|
|
return s.Decode(d)
|
|
}
|
|
|
|
// Encode encodes ListGroupOKApplicationJSON as json.
|
|
func (s ListGroupOKApplicationJSON) Encode(e *jx.Encoder) {
|
|
unwrapped := []GroupList(s)
|
|
|
|
e.ArrStart()
|
|
for _, elem := range unwrapped {
|
|
elem.Encode(e)
|
|
}
|
|
e.ArrEnd()
|
|
}
|
|
|
|
// Decode decodes ListGroupOKApplicationJSON from json.
|
|
func (s *ListGroupOKApplicationJSON) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode ListGroupOKApplicationJSON to nil")
|
|
}
|
|
var unwrapped []GroupList
|
|
if err := func() error {
|
|
unwrapped = make([]GroupList, 0)
|
|
if err := d.Arr(func(d *jx.Decoder) error {
|
|
var elem GroupList
|
|
if err := elem.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
unwrapped = append(unwrapped, elem)
|
|
return nil
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "alias")
|
|
}
|
|
*s = ListGroupOKApplicationJSON(unwrapped)
|
|
return nil
|
|
}
|
|
|
|
// MarshalJSON implements stdjson.Marshaler.
|
|
func (s ListGroupOKApplicationJSON) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *ListGroupOKApplicationJSON) UnmarshalJSON(data []byte) error {
|
|
d := jx.DecodeBytes(data)
|
|
return s.Decode(d)
|
|
}
|
|
|
|
// Encode encodes ListGroupUsersOKApplicationJSON as json.
|
|
func (s ListGroupUsersOKApplicationJSON) Encode(e *jx.Encoder) {
|
|
unwrapped := []GroupUsersList(s)
|
|
|
|
e.ArrStart()
|
|
for _, elem := range unwrapped {
|
|
elem.Encode(e)
|
|
}
|
|
e.ArrEnd()
|
|
}
|
|
|
|
// Decode decodes ListGroupUsersOKApplicationJSON from json.
|
|
func (s *ListGroupUsersOKApplicationJSON) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode ListGroupUsersOKApplicationJSON to nil")
|
|
}
|
|
var unwrapped []GroupUsersList
|
|
if err := func() error {
|
|
unwrapped = make([]GroupUsersList, 0)
|
|
if err := d.Arr(func(d *jx.Decoder) error {
|
|
var elem GroupUsersList
|
|
if err := elem.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
unwrapped = append(unwrapped, elem)
|
|
return nil
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "alias")
|
|
}
|
|
*s = ListGroupUsersOKApplicationJSON(unwrapped)
|
|
return nil
|
|
}
|
|
|
|
// MarshalJSON implements stdjson.Marshaler.
|
|
func (s ListGroupUsersOKApplicationJSON) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *ListGroupUsersOKApplicationJSON) UnmarshalJSON(data []byte) error {
|
|
d := jx.DecodeBytes(data)
|
|
return s.Decode(d)
|
|
}
|
|
|
|
// Encode encodes ListUserCardOKApplicationJSON as json.
|
|
func (s ListUserCardOKApplicationJSON) Encode(e *jx.Encoder) {
|
|
unwrapped := []UserCardList(s)
|
|
|
|
e.ArrStart()
|
|
for _, elem := range unwrapped {
|
|
elem.Encode(e)
|
|
}
|
|
e.ArrEnd()
|
|
}
|
|
|
|
// Decode decodes ListUserCardOKApplicationJSON from json.
|
|
func (s *ListUserCardOKApplicationJSON) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode ListUserCardOKApplicationJSON to nil")
|
|
}
|
|
var unwrapped []UserCardList
|
|
if err := func() error {
|
|
unwrapped = make([]UserCardList, 0)
|
|
if err := d.Arr(func(d *jx.Decoder) error {
|
|
var elem UserCardList
|
|
if err := elem.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
unwrapped = append(unwrapped, elem)
|
|
return nil
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "alias")
|
|
}
|
|
*s = ListUserCardOKApplicationJSON(unwrapped)
|
|
return nil
|
|
}
|
|
|
|
// MarshalJSON implements stdjson.Marshaler.
|
|
func (s ListUserCardOKApplicationJSON) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *ListUserCardOKApplicationJSON) UnmarshalJSON(data []byte) error {
|
|
d := jx.DecodeBytes(data)
|
|
return s.Decode(d)
|
|
}
|
|
|
|
// Encode encodes ListUserOKApplicationJSON as json.
|
|
func (s ListUserOKApplicationJSON) Encode(e *jx.Encoder) {
|
|
unwrapped := []UserList(s)
|
|
|
|
e.ArrStart()
|
|
for _, elem := range unwrapped {
|
|
elem.Encode(e)
|
|
}
|
|
e.ArrEnd()
|
|
}
|
|
|
|
// Decode decodes ListUserOKApplicationJSON from json.
|
|
func (s *ListUserOKApplicationJSON) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode ListUserOKApplicationJSON to nil")
|
|
}
|
|
var unwrapped []UserList
|
|
if err := func() error {
|
|
unwrapped = make([]UserList, 0)
|
|
if err := d.Arr(func(d *jx.Decoder) error {
|
|
var elem UserList
|
|
if err := elem.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
unwrapped = append(unwrapped, elem)
|
|
return nil
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "alias")
|
|
}
|
|
*s = ListUserOKApplicationJSON(unwrapped)
|
|
return nil
|
|
}
|
|
|
|
// MarshalJSON implements stdjson.Marshaler.
|
|
func (s ListUserOKApplicationJSON) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *ListUserOKApplicationJSON) UnmarshalJSON(data []byte) error {
|
|
d := jx.DecodeBytes(data)
|
|
return s.Decode(d)
|
|
}
|
|
|
|
// Encode encodes time.Time as json.
|
|
func (o OptDateTime) Encode(e *jx.Encoder, format func(*jx.Encoder, time.Time)) {
|
|
if !o.Set {
|
|
return
|
|
}
|
|
format(e, o.Value)
|
|
}
|
|
|
|
// Decode decodes time.Time from json.
|
|
func (o *OptDateTime) Decode(d *jx.Decoder, format func(*jx.Decoder) (time.Time, error)) error {
|
|
if o == nil {
|
|
return errors.New("invalid: unable to decode OptDateTime to nil")
|
|
}
|
|
o.Set = true
|
|
v, err := format(d)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
o.Value = v
|
|
return nil
|
|
}
|
|
|
|
// MarshalJSON implements stdjson.Marshaler.
|
|
func (s OptDateTime) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e, json.EncodeDateTime)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *OptDateTime) UnmarshalJSON(data []byte) error {
|
|
d := jx.DecodeBytes(data)
|
|
return s.Decode(d, json.DecodeDateTime)
|
|
}
|
|
|
|
// Encode encodes int as json.
|
|
func (o OptInt) Encode(e *jx.Encoder) {
|
|
if !o.Set {
|
|
return
|
|
}
|
|
e.Int(int(o.Value))
|
|
}
|
|
|
|
// Decode decodes int from json.
|
|
func (o *OptInt) Decode(d *jx.Decoder) error {
|
|
if o == nil {
|
|
return errors.New("invalid: unable to decode OptInt to nil")
|
|
}
|
|
o.Set = true
|
|
v, err := d.Int()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
o.Value = int(v)
|
|
return nil
|
|
}
|
|
|
|
// MarshalJSON implements stdjson.Marshaler.
|
|
func (s OptInt) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *OptInt) 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 *R400) Encode(e *jx.Encoder) {
|
|
e.ObjStart()
|
|
s.encodeFields(e)
|
|
e.ObjEnd()
|
|
}
|
|
|
|
// encodeFields encodes fields.
|
|
func (s *R400) encodeFields(e *jx.Encoder) {
|
|
{
|
|
|
|
e.FieldStart("code")
|
|
e.Int(s.Code)
|
|
}
|
|
{
|
|
|
|
e.FieldStart("status")
|
|
e.Str(s.Status)
|
|
}
|
|
{
|
|
|
|
if len(s.Errors) != 0 {
|
|
e.FieldStart("errors")
|
|
e.Raw(s.Errors)
|
|
}
|
|
}
|
|
}
|
|
|
|
var jsonFieldsNameOfR400 = [3]string{
|
|
0: "code",
|
|
1: "status",
|
|
2: "errors",
|
|
}
|
|
|
|
// Decode decodes R400 from json.
|
|
func (s *R400) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode R400 to nil")
|
|
}
|
|
var requiredBitSet [1]uint8
|
|
|
|
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
|
|
switch string(k) {
|
|
case "code":
|
|
requiredBitSet[0] |= 1 << 0
|
|
if err := func() error {
|
|
v, err := d.Int()
|
|
s.Code = int(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"code\"")
|
|
}
|
|
case "status":
|
|
requiredBitSet[0] |= 1 << 1
|
|
if err := func() error {
|
|
v, err := d.Str()
|
|
s.Status = string(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"status\"")
|
|
}
|
|
case "errors":
|
|
if err := func() error {
|
|
v, err := d.RawAppend(nil)
|
|
s.Errors = jx.Raw(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"errors\"")
|
|
}
|
|
default:
|
|
return d.Skip()
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
return errors.Wrap(err, "decode R400")
|
|
}
|
|
// Validate required fields.
|
|
var failures []validate.FieldError
|
|
for i, mask := range [1]uint8{
|
|
0b00000011,
|
|
} {
|
|
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(jsonFieldsNameOfR400) {
|
|
name = jsonFieldsNameOfR400[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 *R400) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *R400) UnmarshalJSON(data []byte) error {
|
|
d := jx.DecodeBytes(data)
|
|
return s.Decode(d)
|
|
}
|
|
|
|
// Encode implements json.Marshaler.
|
|
func (s *R404) Encode(e *jx.Encoder) {
|
|
e.ObjStart()
|
|
s.encodeFields(e)
|
|
e.ObjEnd()
|
|
}
|
|
|
|
// encodeFields encodes fields.
|
|
func (s *R404) encodeFields(e *jx.Encoder) {
|
|
{
|
|
|
|
e.FieldStart("code")
|
|
e.Int(s.Code)
|
|
}
|
|
{
|
|
|
|
e.FieldStart("status")
|
|
e.Str(s.Status)
|
|
}
|
|
{
|
|
|
|
if len(s.Errors) != 0 {
|
|
e.FieldStart("errors")
|
|
e.Raw(s.Errors)
|
|
}
|
|
}
|
|
}
|
|
|
|
var jsonFieldsNameOfR404 = [3]string{
|
|
0: "code",
|
|
1: "status",
|
|
2: "errors",
|
|
}
|
|
|
|
// Decode decodes R404 from json.
|
|
func (s *R404) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode R404 to nil")
|
|
}
|
|
var requiredBitSet [1]uint8
|
|
|
|
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
|
|
switch string(k) {
|
|
case "code":
|
|
requiredBitSet[0] |= 1 << 0
|
|
if err := func() error {
|
|
v, err := d.Int()
|
|
s.Code = int(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"code\"")
|
|
}
|
|
case "status":
|
|
requiredBitSet[0] |= 1 << 1
|
|
if err := func() error {
|
|
v, err := d.Str()
|
|
s.Status = string(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"status\"")
|
|
}
|
|
case "errors":
|
|
if err := func() error {
|
|
v, err := d.RawAppend(nil)
|
|
s.Errors = jx.Raw(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"errors\"")
|
|
}
|
|
default:
|
|
return d.Skip()
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
return errors.Wrap(err, "decode R404")
|
|
}
|
|
// Validate required fields.
|
|
var failures []validate.FieldError
|
|
for i, mask := range [1]uint8{
|
|
0b00000011,
|
|
} {
|
|
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(jsonFieldsNameOfR404) {
|
|
name = jsonFieldsNameOfR404[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 *R404) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *R404) UnmarshalJSON(data []byte) error {
|
|
d := jx.DecodeBytes(data)
|
|
return s.Decode(d)
|
|
}
|
|
|
|
// Encode implements json.Marshaler.
|
|
func (s *R409) Encode(e *jx.Encoder) {
|
|
e.ObjStart()
|
|
s.encodeFields(e)
|
|
e.ObjEnd()
|
|
}
|
|
|
|
// encodeFields encodes fields.
|
|
func (s *R409) encodeFields(e *jx.Encoder) {
|
|
{
|
|
|
|
e.FieldStart("code")
|
|
e.Int(s.Code)
|
|
}
|
|
{
|
|
|
|
e.FieldStart("status")
|
|
e.Str(s.Status)
|
|
}
|
|
{
|
|
|
|
if len(s.Errors) != 0 {
|
|
e.FieldStart("errors")
|
|
e.Raw(s.Errors)
|
|
}
|
|
}
|
|
}
|
|
|
|
var jsonFieldsNameOfR409 = [3]string{
|
|
0: "code",
|
|
1: "status",
|
|
2: "errors",
|
|
}
|
|
|
|
// Decode decodes R409 from json.
|
|
func (s *R409) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode R409 to nil")
|
|
}
|
|
var requiredBitSet [1]uint8
|
|
|
|
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
|
|
switch string(k) {
|
|
case "code":
|
|
requiredBitSet[0] |= 1 << 0
|
|
if err := func() error {
|
|
v, err := d.Int()
|
|
s.Code = int(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"code\"")
|
|
}
|
|
case "status":
|
|
requiredBitSet[0] |= 1 << 1
|
|
if err := func() error {
|
|
v, err := d.Str()
|
|
s.Status = string(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"status\"")
|
|
}
|
|
case "errors":
|
|
if err := func() error {
|
|
v, err := d.RawAppend(nil)
|
|
s.Errors = jx.Raw(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"errors\"")
|
|
}
|
|
default:
|
|
return d.Skip()
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
return errors.Wrap(err, "decode R409")
|
|
}
|
|
// Validate required fields.
|
|
var failures []validate.FieldError
|
|
for i, mask := range [1]uint8{
|
|
0b00000011,
|
|
} {
|
|
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(jsonFieldsNameOfR409) {
|
|
name = jsonFieldsNameOfR409[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 *R409) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *R409) UnmarshalJSON(data []byte) error {
|
|
d := jx.DecodeBytes(data)
|
|
return s.Decode(d)
|
|
}
|
|
|
|
// Encode implements json.Marshaler.
|
|
func (s *R500) Encode(e *jx.Encoder) {
|
|
e.ObjStart()
|
|
s.encodeFields(e)
|
|
e.ObjEnd()
|
|
}
|
|
|
|
// encodeFields encodes fields.
|
|
func (s *R500) encodeFields(e *jx.Encoder) {
|
|
{
|
|
|
|
e.FieldStart("code")
|
|
e.Int(s.Code)
|
|
}
|
|
{
|
|
|
|
e.FieldStart("status")
|
|
e.Str(s.Status)
|
|
}
|
|
{
|
|
|
|
if len(s.Errors) != 0 {
|
|
e.FieldStart("errors")
|
|
e.Raw(s.Errors)
|
|
}
|
|
}
|
|
}
|
|
|
|
var jsonFieldsNameOfR500 = [3]string{
|
|
0: "code",
|
|
1: "status",
|
|
2: "errors",
|
|
}
|
|
|
|
// Decode decodes R500 from json.
|
|
func (s *R500) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode R500 to nil")
|
|
}
|
|
var requiredBitSet [1]uint8
|
|
|
|
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
|
|
switch string(k) {
|
|
case "code":
|
|
requiredBitSet[0] |= 1 << 0
|
|
if err := func() error {
|
|
v, err := d.Int()
|
|
s.Code = int(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"code\"")
|
|
}
|
|
case "status":
|
|
requiredBitSet[0] |= 1 << 1
|
|
if err := func() error {
|
|
v, err := d.Str()
|
|
s.Status = string(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"status\"")
|
|
}
|
|
case "errors":
|
|
if err := func() error {
|
|
v, err := d.RawAppend(nil)
|
|
s.Errors = jx.Raw(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"errors\"")
|
|
}
|
|
default:
|
|
return d.Skip()
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
return errors.Wrap(err, "decode R500")
|
|
}
|
|
// Validate required fields.
|
|
var failures []validate.FieldError
|
|
for i, mask := range [1]uint8{
|
|
0b00000011,
|
|
} {
|
|
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(jsonFieldsNameOfR500) {
|
|
name = jsonFieldsNameOfR500[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 *R500) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *R500) UnmarshalJSON(data []byte) error {
|
|
d := jx.DecodeBytes(data)
|
|
return s.Decode(d)
|
|
}
|
|
|
|
// Encode implements json.Marshaler.
|
|
func (s *UpdateCardReq) Encode(e *jx.Encoder) {
|
|
e.ObjStart()
|
|
s.encodeFields(e)
|
|
e.ObjEnd()
|
|
}
|
|
|
|
// encodeFields encodes fields.
|
|
func (s *UpdateCardReq) encodeFields(e *jx.Encoder) {
|
|
{
|
|
if s.Owner.Set {
|
|
e.FieldStart("owner")
|
|
s.Owner.Encode(e)
|
|
}
|
|
}
|
|
}
|
|
|
|
var jsonFieldsNameOfUpdateCardReq = [1]string{
|
|
0: "owner",
|
|
}
|
|
|
|
// Decode decodes UpdateCardReq from json.
|
|
func (s *UpdateCardReq) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode UpdateCardReq to nil")
|
|
}
|
|
|
|
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
|
|
switch string(k) {
|
|
case "owner":
|
|
if err := func() error {
|
|
s.Owner.Reset()
|
|
if err := s.Owner.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"owner\"")
|
|
}
|
|
default:
|
|
return d.Skip()
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
return errors.Wrap(err, "decode UpdateCardReq")
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// MarshalJSON implements stdjson.Marshaler.
|
|
func (s *UpdateCardReq) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *UpdateCardReq) UnmarshalJSON(data []byte) error {
|
|
d := jx.DecodeBytes(data)
|
|
return s.Decode(d)
|
|
}
|
|
|
|
// Encode implements json.Marshaler.
|
|
func (s *UpdateGroupReq) Encode(e *jx.Encoder) {
|
|
e.ObjStart()
|
|
s.encodeFields(e)
|
|
e.ObjEnd()
|
|
}
|
|
|
|
// encodeFields encodes fields.
|
|
func (s *UpdateGroupReq) encodeFields(e *jx.Encoder) {
|
|
{
|
|
if s.Name.Set {
|
|
e.FieldStart("name")
|
|
s.Name.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Users != nil {
|
|
e.FieldStart("users")
|
|
e.ArrStart()
|
|
for _, elem := range s.Users {
|
|
e.Int(elem)
|
|
}
|
|
e.ArrEnd()
|
|
}
|
|
}
|
|
}
|
|
|
|
var jsonFieldsNameOfUpdateGroupReq = [2]string{
|
|
0: "name",
|
|
1: "users",
|
|
}
|
|
|
|
// Decode decodes UpdateGroupReq from json.
|
|
func (s *UpdateGroupReq) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode UpdateGroupReq 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 "users":
|
|
if err := func() error {
|
|
s.Users = make([]int, 0)
|
|
if err := d.Arr(func(d *jx.Decoder) error {
|
|
var elem int
|
|
v, err := d.Int()
|
|
elem = int(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
s.Users = append(s.Users, elem)
|
|
return nil
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"users\"")
|
|
}
|
|
default:
|
|
return d.Skip()
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
return errors.Wrap(err, "decode UpdateGroupReq")
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// MarshalJSON implements stdjson.Marshaler.
|
|
func (s *UpdateGroupReq) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *UpdateGroupReq) UnmarshalJSON(data []byte) error {
|
|
d := jx.DecodeBytes(data)
|
|
return s.Decode(d)
|
|
}
|
|
|
|
// Encode implements json.Marshaler.
|
|
func (s *UpdateUserReq) Encode(e *jx.Encoder) {
|
|
e.ObjStart()
|
|
s.encodeFields(e)
|
|
e.ObjEnd()
|
|
}
|
|
|
|
// encodeFields encodes fields.
|
|
func (s *UpdateUserReq) encodeFields(e *jx.Encoder) {
|
|
{
|
|
if s.UpdatedAt.Set {
|
|
e.FieldStart("updated_at")
|
|
s.UpdatedAt.Encode(e, json.EncodeDateTime)
|
|
}
|
|
}
|
|
{
|
|
if s.Next.Set {
|
|
e.FieldStart("next")
|
|
s.Next.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Card != nil {
|
|
e.FieldStart("card")
|
|
e.ArrStart()
|
|
for _, elem := range s.Card {
|
|
e.Int(elem)
|
|
}
|
|
e.ArrEnd()
|
|
}
|
|
}
|
|
}
|
|
|
|
var jsonFieldsNameOfUpdateUserReq = [3]string{
|
|
0: "updated_at",
|
|
1: "next",
|
|
2: "card",
|
|
}
|
|
|
|
// Decode decodes UpdateUserReq from json.
|
|
func (s *UpdateUserReq) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode UpdateUserReq to nil")
|
|
}
|
|
|
|
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
|
|
switch string(k) {
|
|
case "updated_at":
|
|
if err := func() error {
|
|
s.UpdatedAt.Reset()
|
|
if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"updated_at\"")
|
|
}
|
|
case "next":
|
|
if err := func() error {
|
|
s.Next.Reset()
|
|
if err := s.Next.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"next\"")
|
|
}
|
|
case "card":
|
|
if err := func() error {
|
|
s.Card = make([]int, 0)
|
|
if err := d.Arr(func(d *jx.Decoder) error {
|
|
var elem int
|
|
v, err := d.Int()
|
|
elem = int(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
s.Card = append(s.Card, elem)
|
|
return nil
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"card\"")
|
|
}
|
|
default:
|
|
return d.Skip()
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
return errors.Wrap(err, "decode UpdateUserReq")
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// MarshalJSON implements stdjson.Marshaler.
|
|
func (s *UpdateUserReq) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *UpdateUserReq) UnmarshalJSON(data []byte) error {
|
|
d := jx.DecodeBytes(data)
|
|
return s.Decode(d)
|
|
}
|
|
|
|
// Encode implements json.Marshaler.
|
|
func (s *UserCardList) Encode(e *jx.Encoder) {
|
|
e.ObjStart()
|
|
s.encodeFields(e)
|
|
e.ObjEnd()
|
|
}
|
|
|
|
// encodeFields encodes fields.
|
|
func (s *UserCardList) encodeFields(e *jx.Encoder) {
|
|
{
|
|
|
|
e.FieldStart("id")
|
|
e.Int(s.ID)
|
|
}
|
|
{
|
|
if s.Card.Set {
|
|
e.FieldStart("card")
|
|
s.Card.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Status.Set {
|
|
e.FieldStart("status")
|
|
s.Status.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Cp.Set {
|
|
e.FieldStart("cp")
|
|
s.Cp.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.URL.Set {
|
|
e.FieldStart("url")
|
|
s.URL.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.CreatedAt.Set {
|
|
e.FieldStart("created_at")
|
|
s.CreatedAt.Encode(e, json.EncodeDateTime)
|
|
}
|
|
}
|
|
}
|
|
|
|
var jsonFieldsNameOfUserCardList = [6]string{
|
|
0: "id",
|
|
1: "card",
|
|
2: "status",
|
|
3: "cp",
|
|
4: "url",
|
|
5: "created_at",
|
|
}
|
|
|
|
// Decode decodes UserCardList from json.
|
|
func (s *UserCardList) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode UserCardList to nil")
|
|
}
|
|
var requiredBitSet [1]uint8
|
|
|
|
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
|
|
switch string(k) {
|
|
case "id":
|
|
requiredBitSet[0] |= 1 << 0
|
|
if err := func() error {
|
|
v, err := d.Int()
|
|
s.ID = int(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"id\"")
|
|
}
|
|
case "card":
|
|
if err := func() error {
|
|
s.Card.Reset()
|
|
if err := s.Card.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"card\"")
|
|
}
|
|
case "status":
|
|
if err := func() error {
|
|
s.Status.Reset()
|
|
if err := s.Status.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"status\"")
|
|
}
|
|
case "cp":
|
|
if err := func() error {
|
|
s.Cp.Reset()
|
|
if err := s.Cp.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"cp\"")
|
|
}
|
|
case "url":
|
|
if err := func() error {
|
|
s.URL.Reset()
|
|
if err := s.URL.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"url\"")
|
|
}
|
|
case "created_at":
|
|
if err := func() error {
|
|
s.CreatedAt.Reset()
|
|
if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"created_at\"")
|
|
}
|
|
default:
|
|
return d.Skip()
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
return errors.Wrap(err, "decode UserCardList")
|
|
}
|
|
// 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(jsonFieldsNameOfUserCardList) {
|
|
name = jsonFieldsNameOfUserCardList[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 *UserCardList) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *UserCardList) UnmarshalJSON(data []byte) error {
|
|
d := jx.DecodeBytes(data)
|
|
return s.Decode(d)
|
|
}
|
|
|
|
// Encode implements json.Marshaler.
|
|
func (s *UserCreate) Encode(e *jx.Encoder) {
|
|
e.ObjStart()
|
|
s.encodeFields(e)
|
|
e.ObjEnd()
|
|
}
|
|
|
|
// encodeFields encodes fields.
|
|
func (s *UserCreate) encodeFields(e *jx.Encoder) {
|
|
{
|
|
|
|
e.FieldStart("id")
|
|
e.Int(s.ID)
|
|
}
|
|
{
|
|
|
|
e.FieldStart("username")
|
|
e.Str(s.Username)
|
|
}
|
|
{
|
|
if s.CreatedAt.Set {
|
|
e.FieldStart("created_at")
|
|
s.CreatedAt.Encode(e, json.EncodeDateTime)
|
|
}
|
|
}
|
|
{
|
|
if s.UpdatedAt.Set {
|
|
e.FieldStart("updated_at")
|
|
s.UpdatedAt.Encode(e, json.EncodeDateTime)
|
|
}
|
|
}
|
|
{
|
|
if s.Next.Set {
|
|
e.FieldStart("next")
|
|
s.Next.Encode(e)
|
|
}
|
|
}
|
|
}
|
|
|
|
var jsonFieldsNameOfUserCreate = [5]string{
|
|
0: "id",
|
|
1: "username",
|
|
2: "created_at",
|
|
3: "updated_at",
|
|
4: "next",
|
|
}
|
|
|
|
// Decode decodes UserCreate from json.
|
|
func (s *UserCreate) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode UserCreate to nil")
|
|
}
|
|
var requiredBitSet [1]uint8
|
|
|
|
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
|
|
switch string(k) {
|
|
case "id":
|
|
requiredBitSet[0] |= 1 << 0
|
|
if err := func() error {
|
|
v, err := d.Int()
|
|
s.ID = int(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"id\"")
|
|
}
|
|
case "username":
|
|
requiredBitSet[0] |= 1 << 1
|
|
if err := func() error {
|
|
v, err := d.Str()
|
|
s.Username = string(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"username\"")
|
|
}
|
|
case "created_at":
|
|
if err := func() error {
|
|
s.CreatedAt.Reset()
|
|
if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"created_at\"")
|
|
}
|
|
case "updated_at":
|
|
if err := func() error {
|
|
s.UpdatedAt.Reset()
|
|
if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"updated_at\"")
|
|
}
|
|
case "next":
|
|
if err := func() error {
|
|
s.Next.Reset()
|
|
if err := s.Next.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"next\"")
|
|
}
|
|
default:
|
|
return d.Skip()
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
return errors.Wrap(err, "decode UserCreate")
|
|
}
|
|
// Validate required fields.
|
|
var failures []validate.FieldError
|
|
for i, mask := range [1]uint8{
|
|
0b00000011,
|
|
} {
|
|
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(jsonFieldsNameOfUserCreate) {
|
|
name = jsonFieldsNameOfUserCreate[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 *UserCreate) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *UserCreate) UnmarshalJSON(data []byte) error {
|
|
d := jx.DecodeBytes(data)
|
|
return s.Decode(d)
|
|
}
|
|
|
|
// Encode implements json.Marshaler.
|
|
func (s *UserList) Encode(e *jx.Encoder) {
|
|
e.ObjStart()
|
|
s.encodeFields(e)
|
|
e.ObjEnd()
|
|
}
|
|
|
|
// encodeFields encodes fields.
|
|
func (s *UserList) encodeFields(e *jx.Encoder) {
|
|
{
|
|
|
|
e.FieldStart("id")
|
|
e.Int(s.ID)
|
|
}
|
|
{
|
|
|
|
e.FieldStart("username")
|
|
e.Str(s.Username)
|
|
}
|
|
{
|
|
if s.CreatedAt.Set {
|
|
e.FieldStart("created_at")
|
|
s.CreatedAt.Encode(e, json.EncodeDateTime)
|
|
}
|
|
}
|
|
{
|
|
if s.UpdatedAt.Set {
|
|
e.FieldStart("updated_at")
|
|
s.UpdatedAt.Encode(e, json.EncodeDateTime)
|
|
}
|
|
}
|
|
{
|
|
if s.Next.Set {
|
|
e.FieldStart("next")
|
|
s.Next.Encode(e)
|
|
}
|
|
}
|
|
}
|
|
|
|
var jsonFieldsNameOfUserList = [5]string{
|
|
0: "id",
|
|
1: "username",
|
|
2: "created_at",
|
|
3: "updated_at",
|
|
4: "next",
|
|
}
|
|
|
|
// Decode decodes UserList from json.
|
|
func (s *UserList) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode UserList to nil")
|
|
}
|
|
var requiredBitSet [1]uint8
|
|
|
|
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
|
|
switch string(k) {
|
|
case "id":
|
|
requiredBitSet[0] |= 1 << 0
|
|
if err := func() error {
|
|
v, err := d.Int()
|
|
s.ID = int(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"id\"")
|
|
}
|
|
case "username":
|
|
requiredBitSet[0] |= 1 << 1
|
|
if err := func() error {
|
|
v, err := d.Str()
|
|
s.Username = string(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"username\"")
|
|
}
|
|
case "created_at":
|
|
if err := func() error {
|
|
s.CreatedAt.Reset()
|
|
if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"created_at\"")
|
|
}
|
|
case "updated_at":
|
|
if err := func() error {
|
|
s.UpdatedAt.Reset()
|
|
if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"updated_at\"")
|
|
}
|
|
case "next":
|
|
if err := func() error {
|
|
s.Next.Reset()
|
|
if err := s.Next.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"next\"")
|
|
}
|
|
default:
|
|
return d.Skip()
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
return errors.Wrap(err, "decode UserList")
|
|
}
|
|
// Validate required fields.
|
|
var failures []validate.FieldError
|
|
for i, mask := range [1]uint8{
|
|
0b00000011,
|
|
} {
|
|
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(jsonFieldsNameOfUserList) {
|
|
name = jsonFieldsNameOfUserList[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 *UserList) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *UserList) UnmarshalJSON(data []byte) error {
|
|
d := jx.DecodeBytes(data)
|
|
return s.Decode(d)
|
|
}
|
|
|
|
// Encode implements json.Marshaler.
|
|
func (s *UserRead) Encode(e *jx.Encoder) {
|
|
e.ObjStart()
|
|
s.encodeFields(e)
|
|
e.ObjEnd()
|
|
}
|
|
|
|
// encodeFields encodes fields.
|
|
func (s *UserRead) encodeFields(e *jx.Encoder) {
|
|
{
|
|
|
|
e.FieldStart("id")
|
|
e.Int(s.ID)
|
|
}
|
|
{
|
|
|
|
e.FieldStart("username")
|
|
e.Str(s.Username)
|
|
}
|
|
{
|
|
if s.CreatedAt.Set {
|
|
e.FieldStart("created_at")
|
|
s.CreatedAt.Encode(e, json.EncodeDateTime)
|
|
}
|
|
}
|
|
{
|
|
if s.UpdatedAt.Set {
|
|
e.FieldStart("updated_at")
|
|
s.UpdatedAt.Encode(e, json.EncodeDateTime)
|
|
}
|
|
}
|
|
{
|
|
if s.Next.Set {
|
|
e.FieldStart("next")
|
|
s.Next.Encode(e)
|
|
}
|
|
}
|
|
}
|
|
|
|
var jsonFieldsNameOfUserRead = [5]string{
|
|
0: "id",
|
|
1: "username",
|
|
2: "created_at",
|
|
3: "updated_at",
|
|
4: "next",
|
|
}
|
|
|
|
// Decode decodes UserRead from json.
|
|
func (s *UserRead) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode UserRead to nil")
|
|
}
|
|
var requiredBitSet [1]uint8
|
|
|
|
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
|
|
switch string(k) {
|
|
case "id":
|
|
requiredBitSet[0] |= 1 << 0
|
|
if err := func() error {
|
|
v, err := d.Int()
|
|
s.ID = int(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"id\"")
|
|
}
|
|
case "username":
|
|
requiredBitSet[0] |= 1 << 1
|
|
if err := func() error {
|
|
v, err := d.Str()
|
|
s.Username = string(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"username\"")
|
|
}
|
|
case "created_at":
|
|
if err := func() error {
|
|
s.CreatedAt.Reset()
|
|
if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"created_at\"")
|
|
}
|
|
case "updated_at":
|
|
if err := func() error {
|
|
s.UpdatedAt.Reset()
|
|
if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"updated_at\"")
|
|
}
|
|
case "next":
|
|
if err := func() error {
|
|
s.Next.Reset()
|
|
if err := s.Next.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"next\"")
|
|
}
|
|
default:
|
|
return d.Skip()
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
return errors.Wrap(err, "decode UserRead")
|
|
}
|
|
// Validate required fields.
|
|
var failures []validate.FieldError
|
|
for i, mask := range [1]uint8{
|
|
0b00000011,
|
|
} {
|
|
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(jsonFieldsNameOfUserRead) {
|
|
name = jsonFieldsNameOfUserRead[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 *UserRead) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *UserRead) UnmarshalJSON(data []byte) error {
|
|
d := jx.DecodeBytes(data)
|
|
return s.Decode(d)
|
|
}
|
|
|
|
// Encode implements json.Marshaler.
|
|
func (s *UserUpdate) Encode(e *jx.Encoder) {
|
|
e.ObjStart()
|
|
s.encodeFields(e)
|
|
e.ObjEnd()
|
|
}
|
|
|
|
// encodeFields encodes fields.
|
|
func (s *UserUpdate) encodeFields(e *jx.Encoder) {
|
|
{
|
|
|
|
e.FieldStart("id")
|
|
e.Int(s.ID)
|
|
}
|
|
{
|
|
|
|
e.FieldStart("username")
|
|
e.Str(s.Username)
|
|
}
|
|
{
|
|
if s.CreatedAt.Set {
|
|
e.FieldStart("created_at")
|
|
s.CreatedAt.Encode(e, json.EncodeDateTime)
|
|
}
|
|
}
|
|
{
|
|
if s.UpdatedAt.Set {
|
|
e.FieldStart("updated_at")
|
|
s.UpdatedAt.Encode(e, json.EncodeDateTime)
|
|
}
|
|
}
|
|
{
|
|
if s.Next.Set {
|
|
e.FieldStart("next")
|
|
s.Next.Encode(e)
|
|
}
|
|
}
|
|
}
|
|
|
|
var jsonFieldsNameOfUserUpdate = [5]string{
|
|
0: "id",
|
|
1: "username",
|
|
2: "created_at",
|
|
3: "updated_at",
|
|
4: "next",
|
|
}
|
|
|
|
// Decode decodes UserUpdate from json.
|
|
func (s *UserUpdate) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode UserUpdate to nil")
|
|
}
|
|
var requiredBitSet [1]uint8
|
|
|
|
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
|
|
switch string(k) {
|
|
case "id":
|
|
requiredBitSet[0] |= 1 << 0
|
|
if err := func() error {
|
|
v, err := d.Int()
|
|
s.ID = int(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"id\"")
|
|
}
|
|
case "username":
|
|
requiredBitSet[0] |= 1 << 1
|
|
if err := func() error {
|
|
v, err := d.Str()
|
|
s.Username = string(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"username\"")
|
|
}
|
|
case "created_at":
|
|
if err := func() error {
|
|
s.CreatedAt.Reset()
|
|
if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"created_at\"")
|
|
}
|
|
case "updated_at":
|
|
if err := func() error {
|
|
s.UpdatedAt.Reset()
|
|
if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"updated_at\"")
|
|
}
|
|
case "next":
|
|
if err := func() error {
|
|
s.Next.Reset()
|
|
if err := s.Next.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"next\"")
|
|
}
|
|
default:
|
|
return d.Skip()
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
return errors.Wrap(err, "decode UserUpdate")
|
|
}
|
|
// Validate required fields.
|
|
var failures []validate.FieldError
|
|
for i, mask := range [1]uint8{
|
|
0b00000011,
|
|
} {
|
|
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(jsonFieldsNameOfUserUpdate) {
|
|
name = jsonFieldsNameOfUserUpdate[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 *UserUpdate) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *UserUpdate) UnmarshalJSON(data []byte) error {
|
|
d := jx.DecodeBytes(data)
|
|
return s.Decode(d)
|
|
}
|