2834 lines
61 KiB
Go
2834 lines
61 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 *CreatePasswordTokenReq) Encode(e *jx.Encoder) {
|
|
e.ObjStart()
|
|
s.encodeFields(e)
|
|
e.ObjEnd()
|
|
}
|
|
|
|
// encodeFields encodes fields.
|
|
func (s *CreatePasswordTokenReq) encodeFields(e *jx.Encoder) {
|
|
{
|
|
|
|
e.FieldStart("hash")
|
|
e.Str(s.Hash)
|
|
}
|
|
{
|
|
|
|
e.FieldStart("created_at")
|
|
json.EncodeDateTime(e, s.CreatedAt)
|
|
}
|
|
{
|
|
|
|
e.FieldStart("user")
|
|
e.Int(s.User)
|
|
}
|
|
}
|
|
|
|
var jsonFieldsNameOfCreatePasswordTokenReq = [3]string{
|
|
0: "hash",
|
|
1: "created_at",
|
|
2: "user",
|
|
}
|
|
|
|
// Decode decodes CreatePasswordTokenReq from json.
|
|
func (s *CreatePasswordTokenReq) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode CreatePasswordTokenReq to nil")
|
|
}
|
|
var requiredBitSet [1]uint8
|
|
|
|
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
|
|
switch string(k) {
|
|
case "hash":
|
|
requiredBitSet[0] |= 1 << 0
|
|
if err := func() error {
|
|
v, err := d.Str()
|
|
s.Hash = string(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"hash\"")
|
|
}
|
|
case "created_at":
|
|
requiredBitSet[0] |= 1 << 1
|
|
if err := func() error {
|
|
v, err := json.DecodeDateTime(d)
|
|
s.CreatedAt = v
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"created_at\"")
|
|
}
|
|
case "user":
|
|
requiredBitSet[0] |= 1 << 2
|
|
if err := func() error {
|
|
v, err := d.Int()
|
|
s.User = int(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"user\"")
|
|
}
|
|
default:
|
|
return d.Skip()
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
return errors.Wrap(err, "decode CreatePasswordTokenReq")
|
|
}
|
|
// Validate required fields.
|
|
var failures []validate.FieldError
|
|
for i, mask := range [1]uint8{
|
|
0b00000111,
|
|
} {
|
|
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(jsonFieldsNameOfCreatePasswordTokenReq) {
|
|
name = jsonFieldsNameOfCreatePasswordTokenReq[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 *CreatePasswordTokenReq) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *CreatePasswordTokenReq) 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("name")
|
|
e.Str(s.Name)
|
|
}
|
|
{
|
|
|
|
e.FieldStart("email")
|
|
e.Str(s.Email)
|
|
}
|
|
{
|
|
|
|
e.FieldStart("password")
|
|
e.Str(s.Password)
|
|
}
|
|
{
|
|
|
|
e.FieldStart("verified")
|
|
e.Bool(s.Verified)
|
|
}
|
|
{
|
|
|
|
e.FieldStart("created_at")
|
|
json.EncodeDateTime(e, s.CreatedAt)
|
|
}
|
|
{
|
|
if s.Owner != nil {
|
|
e.FieldStart("owner")
|
|
e.ArrStart()
|
|
for _, elem := range s.Owner {
|
|
e.Int(elem)
|
|
}
|
|
e.ArrEnd()
|
|
}
|
|
}
|
|
}
|
|
|
|
var jsonFieldsNameOfCreateUserReq = [6]string{
|
|
0: "name",
|
|
1: "email",
|
|
2: "password",
|
|
3: "verified",
|
|
4: "created_at",
|
|
5: "owner",
|
|
}
|
|
|
|
// 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 "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 "email":
|
|
requiredBitSet[0] |= 1 << 1
|
|
if err := func() error {
|
|
v, err := d.Str()
|
|
s.Email = string(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"email\"")
|
|
}
|
|
case "password":
|
|
requiredBitSet[0] |= 1 << 2
|
|
if err := func() error {
|
|
v, err := d.Str()
|
|
s.Password = string(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"password\"")
|
|
}
|
|
case "verified":
|
|
requiredBitSet[0] |= 1 << 3
|
|
if err := func() error {
|
|
v, err := d.Bool()
|
|
s.Verified = bool(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"verified\"")
|
|
}
|
|
case "created_at":
|
|
requiredBitSet[0] |= 1 << 4
|
|
if err := func() error {
|
|
v, err := json.DecodeDateTime(d)
|
|
s.CreatedAt = v
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"created_at\"")
|
|
}
|
|
case "owner":
|
|
if err := func() error {
|
|
s.Owner = 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.Owner = append(s.Owner, elem)
|
|
return nil
|
|
}); 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 CreateUserReq")
|
|
}
|
|
// Validate required fields.
|
|
var failures []validate.FieldError
|
|
for i, mask := range [1]uint8{
|
|
0b00011111,
|
|
} {
|
|
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 encodes ListPasswordTokenOKApplicationJSON as json.
|
|
func (s ListPasswordTokenOKApplicationJSON) Encode(e *jx.Encoder) {
|
|
unwrapped := []PasswordTokenList(s)
|
|
|
|
e.ArrStart()
|
|
for _, elem := range unwrapped {
|
|
elem.Encode(e)
|
|
}
|
|
e.ArrEnd()
|
|
}
|
|
|
|
// Decode decodes ListPasswordTokenOKApplicationJSON from json.
|
|
func (s *ListPasswordTokenOKApplicationJSON) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode ListPasswordTokenOKApplicationJSON to nil")
|
|
}
|
|
var unwrapped []PasswordTokenList
|
|
if err := func() error {
|
|
unwrapped = make([]PasswordTokenList, 0)
|
|
if err := d.Arr(func(d *jx.Decoder) error {
|
|
var elem PasswordTokenList
|
|
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 = ListPasswordTokenOKApplicationJSON(unwrapped)
|
|
return nil
|
|
}
|
|
|
|
// MarshalJSON implements stdjson.Marshaler.
|
|
func (s ListPasswordTokenOKApplicationJSON) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *ListPasswordTokenOKApplicationJSON) 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 ListUserOwnerOKApplicationJSON as json.
|
|
func (s ListUserOwnerOKApplicationJSON) Encode(e *jx.Encoder) {
|
|
unwrapped := []UserOwnerList(s)
|
|
|
|
e.ArrStart()
|
|
for _, elem := range unwrapped {
|
|
elem.Encode(e)
|
|
}
|
|
e.ArrEnd()
|
|
}
|
|
|
|
// Decode decodes ListUserOwnerOKApplicationJSON from json.
|
|
func (s *ListUserOwnerOKApplicationJSON) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode ListUserOwnerOKApplicationJSON to nil")
|
|
}
|
|
var unwrapped []UserOwnerList
|
|
if err := func() error {
|
|
unwrapped = make([]UserOwnerList, 0)
|
|
if err := d.Arr(func(d *jx.Decoder) error {
|
|
var elem UserOwnerList
|
|
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 = ListUserOwnerOKApplicationJSON(unwrapped)
|
|
return nil
|
|
}
|
|
|
|
// MarshalJSON implements stdjson.Marshaler.
|
|
func (s ListUserOwnerOKApplicationJSON) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *ListUserOwnerOKApplicationJSON) UnmarshalJSON(data []byte) error {
|
|
d := jx.DecodeBytes(data)
|
|
return s.Decode(d)
|
|
}
|
|
|
|
// Encode encodes bool as json.
|
|
func (o OptBool) Encode(e *jx.Encoder) {
|
|
if !o.Set {
|
|
return
|
|
}
|
|
e.Bool(bool(o.Value))
|
|
}
|
|
|
|
// Decode decodes bool from json.
|
|
func (o *OptBool) Decode(d *jx.Decoder) error {
|
|
if o == nil {
|
|
return errors.New("invalid: unable to decode OptBool to nil")
|
|
}
|
|
o.Set = true
|
|
v, err := d.Bool()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
o.Value = bool(v)
|
|
return nil
|
|
}
|
|
|
|
// MarshalJSON implements stdjson.Marshaler.
|
|
func (s OptBool) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *OptBool) UnmarshalJSON(data []byte) error {
|
|
d := jx.DecodeBytes(data)
|
|
return s.Decode(d)
|
|
}
|
|
|
|
// Encode encodes 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 *PasswordTokenCreate) Encode(e *jx.Encoder) {
|
|
e.ObjStart()
|
|
s.encodeFields(e)
|
|
e.ObjEnd()
|
|
}
|
|
|
|
// encodeFields encodes fields.
|
|
func (s *PasswordTokenCreate) encodeFields(e *jx.Encoder) {
|
|
{
|
|
|
|
e.FieldStart("id")
|
|
e.Int(s.ID)
|
|
}
|
|
{
|
|
|
|
e.FieldStart("created_at")
|
|
json.EncodeDateTime(e, s.CreatedAt)
|
|
}
|
|
}
|
|
|
|
var jsonFieldsNameOfPasswordTokenCreate = [2]string{
|
|
0: "id",
|
|
1: "created_at",
|
|
}
|
|
|
|
// Decode decodes PasswordTokenCreate from json.
|
|
func (s *PasswordTokenCreate) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode PasswordTokenCreate 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 "created_at":
|
|
requiredBitSet[0] |= 1 << 1
|
|
if err := func() error {
|
|
v, err := json.DecodeDateTime(d)
|
|
s.CreatedAt = v
|
|
if 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 PasswordTokenCreate")
|
|
}
|
|
// 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(jsonFieldsNameOfPasswordTokenCreate) {
|
|
name = jsonFieldsNameOfPasswordTokenCreate[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 *PasswordTokenCreate) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *PasswordTokenCreate) UnmarshalJSON(data []byte) error {
|
|
d := jx.DecodeBytes(data)
|
|
return s.Decode(d)
|
|
}
|
|
|
|
// Encode implements json.Marshaler.
|
|
func (s *PasswordTokenList) Encode(e *jx.Encoder) {
|
|
e.ObjStart()
|
|
s.encodeFields(e)
|
|
e.ObjEnd()
|
|
}
|
|
|
|
// encodeFields encodes fields.
|
|
func (s *PasswordTokenList) encodeFields(e *jx.Encoder) {
|
|
{
|
|
|
|
e.FieldStart("id")
|
|
e.Int(s.ID)
|
|
}
|
|
{
|
|
|
|
e.FieldStart("created_at")
|
|
json.EncodeDateTime(e, s.CreatedAt)
|
|
}
|
|
}
|
|
|
|
var jsonFieldsNameOfPasswordTokenList = [2]string{
|
|
0: "id",
|
|
1: "created_at",
|
|
}
|
|
|
|
// Decode decodes PasswordTokenList from json.
|
|
func (s *PasswordTokenList) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode PasswordTokenList 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 "created_at":
|
|
requiredBitSet[0] |= 1 << 1
|
|
if err := func() error {
|
|
v, err := json.DecodeDateTime(d)
|
|
s.CreatedAt = v
|
|
if 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 PasswordTokenList")
|
|
}
|
|
// 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(jsonFieldsNameOfPasswordTokenList) {
|
|
name = jsonFieldsNameOfPasswordTokenList[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 *PasswordTokenList) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *PasswordTokenList) UnmarshalJSON(data []byte) error {
|
|
d := jx.DecodeBytes(data)
|
|
return s.Decode(d)
|
|
}
|
|
|
|
// Encode implements json.Marshaler.
|
|
func (s *PasswordTokenRead) Encode(e *jx.Encoder) {
|
|
e.ObjStart()
|
|
s.encodeFields(e)
|
|
e.ObjEnd()
|
|
}
|
|
|
|
// encodeFields encodes fields.
|
|
func (s *PasswordTokenRead) encodeFields(e *jx.Encoder) {
|
|
{
|
|
|
|
e.FieldStart("id")
|
|
e.Int(s.ID)
|
|
}
|
|
{
|
|
|
|
e.FieldStart("created_at")
|
|
json.EncodeDateTime(e, s.CreatedAt)
|
|
}
|
|
}
|
|
|
|
var jsonFieldsNameOfPasswordTokenRead = [2]string{
|
|
0: "id",
|
|
1: "created_at",
|
|
}
|
|
|
|
// Decode decodes PasswordTokenRead from json.
|
|
func (s *PasswordTokenRead) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode PasswordTokenRead 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 "created_at":
|
|
requiredBitSet[0] |= 1 << 1
|
|
if err := func() error {
|
|
v, err := json.DecodeDateTime(d)
|
|
s.CreatedAt = v
|
|
if 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 PasswordTokenRead")
|
|
}
|
|
// 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(jsonFieldsNameOfPasswordTokenRead) {
|
|
name = jsonFieldsNameOfPasswordTokenRead[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 *PasswordTokenRead) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *PasswordTokenRead) UnmarshalJSON(data []byte) error {
|
|
d := jx.DecodeBytes(data)
|
|
return s.Decode(d)
|
|
}
|
|
|
|
// Encode implements json.Marshaler.
|
|
func (s *PasswordTokenUpdate) Encode(e *jx.Encoder) {
|
|
e.ObjStart()
|
|
s.encodeFields(e)
|
|
e.ObjEnd()
|
|
}
|
|
|
|
// encodeFields encodes fields.
|
|
func (s *PasswordTokenUpdate) encodeFields(e *jx.Encoder) {
|
|
{
|
|
|
|
e.FieldStart("id")
|
|
e.Int(s.ID)
|
|
}
|
|
{
|
|
|
|
e.FieldStart("created_at")
|
|
json.EncodeDateTime(e, s.CreatedAt)
|
|
}
|
|
}
|
|
|
|
var jsonFieldsNameOfPasswordTokenUpdate = [2]string{
|
|
0: "id",
|
|
1: "created_at",
|
|
}
|
|
|
|
// Decode decodes PasswordTokenUpdate from json.
|
|
func (s *PasswordTokenUpdate) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode PasswordTokenUpdate 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 "created_at":
|
|
requiredBitSet[0] |= 1 << 1
|
|
if err := func() error {
|
|
v, err := json.DecodeDateTime(d)
|
|
s.CreatedAt = v
|
|
if 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 PasswordTokenUpdate")
|
|
}
|
|
// 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(jsonFieldsNameOfPasswordTokenUpdate) {
|
|
name = jsonFieldsNameOfPasswordTokenUpdate[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 *PasswordTokenUpdate) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *PasswordTokenUpdate) UnmarshalJSON(data []byte) error {
|
|
d := jx.DecodeBytes(data)
|
|
return s.Decode(d)
|
|
}
|
|
|
|
// Encode implements json.Marshaler.
|
|
func (s *PasswordTokenUserRead) Encode(e *jx.Encoder) {
|
|
e.ObjStart()
|
|
s.encodeFields(e)
|
|
e.ObjEnd()
|
|
}
|
|
|
|
// encodeFields encodes fields.
|
|
func (s *PasswordTokenUserRead) encodeFields(e *jx.Encoder) {
|
|
{
|
|
|
|
e.FieldStart("id")
|
|
e.Int(s.ID)
|
|
}
|
|
{
|
|
|
|
e.FieldStart("name")
|
|
e.Str(s.Name)
|
|
}
|
|
{
|
|
|
|
e.FieldStart("email")
|
|
e.Str(s.Email)
|
|
}
|
|
{
|
|
|
|
e.FieldStart("verified")
|
|
e.Bool(s.Verified)
|
|
}
|
|
{
|
|
|
|
e.FieldStart("created_at")
|
|
json.EncodeDateTime(e, s.CreatedAt)
|
|
}
|
|
}
|
|
|
|
var jsonFieldsNameOfPasswordTokenUserRead = [5]string{
|
|
0: "id",
|
|
1: "name",
|
|
2: "email",
|
|
3: "verified",
|
|
4: "created_at",
|
|
}
|
|
|
|
// Decode decodes PasswordTokenUserRead from json.
|
|
func (s *PasswordTokenUserRead) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode PasswordTokenUserRead 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\"")
|
|
}
|
|
case "email":
|
|
requiredBitSet[0] |= 1 << 2
|
|
if err := func() error {
|
|
v, err := d.Str()
|
|
s.Email = string(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"email\"")
|
|
}
|
|
case "verified":
|
|
requiredBitSet[0] |= 1 << 3
|
|
if err := func() error {
|
|
v, err := d.Bool()
|
|
s.Verified = bool(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"verified\"")
|
|
}
|
|
case "created_at":
|
|
requiredBitSet[0] |= 1 << 4
|
|
if err := func() error {
|
|
v, err := json.DecodeDateTime(d)
|
|
s.CreatedAt = v
|
|
if 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 PasswordTokenUserRead")
|
|
}
|
|
// Validate required fields.
|
|
var failures []validate.FieldError
|
|
for i, mask := range [1]uint8{
|
|
0b00011111,
|
|
} {
|
|
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(jsonFieldsNameOfPasswordTokenUserRead) {
|
|
name = jsonFieldsNameOfPasswordTokenUserRead[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 *PasswordTokenUserRead) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *PasswordTokenUserRead) 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 *UpdatePasswordTokenReq) Encode(e *jx.Encoder) {
|
|
e.ObjStart()
|
|
s.encodeFields(e)
|
|
e.ObjEnd()
|
|
}
|
|
|
|
// encodeFields encodes fields.
|
|
func (s *UpdatePasswordTokenReq) encodeFields(e *jx.Encoder) {
|
|
{
|
|
if s.Hash.Set {
|
|
e.FieldStart("hash")
|
|
s.Hash.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.CreatedAt.Set {
|
|
e.FieldStart("created_at")
|
|
s.CreatedAt.Encode(e, json.EncodeDateTime)
|
|
}
|
|
}
|
|
{
|
|
if s.User.Set {
|
|
e.FieldStart("user")
|
|
s.User.Encode(e)
|
|
}
|
|
}
|
|
}
|
|
|
|
var jsonFieldsNameOfUpdatePasswordTokenReq = [3]string{
|
|
0: "hash",
|
|
1: "created_at",
|
|
2: "user",
|
|
}
|
|
|
|
// Decode decodes UpdatePasswordTokenReq from json.
|
|
func (s *UpdatePasswordTokenReq) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode UpdatePasswordTokenReq to nil")
|
|
}
|
|
|
|
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
|
|
switch string(k) {
|
|
case "hash":
|
|
if err := func() error {
|
|
s.Hash.Reset()
|
|
if err := s.Hash.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"hash\"")
|
|
}
|
|
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 "user":
|
|
if err := func() error {
|
|
s.User.Reset()
|
|
if err := s.User.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"user\"")
|
|
}
|
|
default:
|
|
return d.Skip()
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
return errors.Wrap(err, "decode UpdatePasswordTokenReq")
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// MarshalJSON implements stdjson.Marshaler.
|
|
func (s *UpdatePasswordTokenReq) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *UpdatePasswordTokenReq) 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.Name.Set {
|
|
e.FieldStart("name")
|
|
s.Name.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Email.Set {
|
|
e.FieldStart("email")
|
|
s.Email.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Password.Set {
|
|
e.FieldStart("password")
|
|
s.Password.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Verified.Set {
|
|
e.FieldStart("verified")
|
|
s.Verified.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Owner != nil {
|
|
e.FieldStart("owner")
|
|
e.ArrStart()
|
|
for _, elem := range s.Owner {
|
|
e.Int(elem)
|
|
}
|
|
e.ArrEnd()
|
|
}
|
|
}
|
|
}
|
|
|
|
var jsonFieldsNameOfUpdateUserReq = [5]string{
|
|
0: "name",
|
|
1: "email",
|
|
2: "password",
|
|
3: "verified",
|
|
4: "owner",
|
|
}
|
|
|
|
// 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 "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 "email":
|
|
if err := func() error {
|
|
s.Email.Reset()
|
|
if err := s.Email.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"email\"")
|
|
}
|
|
case "password":
|
|
if err := func() error {
|
|
s.Password.Reset()
|
|
if err := s.Password.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"password\"")
|
|
}
|
|
case "verified":
|
|
if err := func() error {
|
|
s.Verified.Reset()
|
|
if err := s.Verified.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"verified\"")
|
|
}
|
|
case "owner":
|
|
if err := func() error {
|
|
s.Owner = 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.Owner = append(s.Owner, elem)
|
|
return nil
|
|
}); 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 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 *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("name")
|
|
e.Str(s.Name)
|
|
}
|
|
{
|
|
|
|
e.FieldStart("email")
|
|
e.Str(s.Email)
|
|
}
|
|
{
|
|
|
|
e.FieldStart("verified")
|
|
e.Bool(s.Verified)
|
|
}
|
|
{
|
|
|
|
e.FieldStart("created_at")
|
|
json.EncodeDateTime(e, s.CreatedAt)
|
|
}
|
|
}
|
|
|
|
var jsonFieldsNameOfUserCreate = [5]string{
|
|
0: "id",
|
|
1: "name",
|
|
2: "email",
|
|
3: "verified",
|
|
4: "created_at",
|
|
}
|
|
|
|
// 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 "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\"")
|
|
}
|
|
case "email":
|
|
requiredBitSet[0] |= 1 << 2
|
|
if err := func() error {
|
|
v, err := d.Str()
|
|
s.Email = string(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"email\"")
|
|
}
|
|
case "verified":
|
|
requiredBitSet[0] |= 1 << 3
|
|
if err := func() error {
|
|
v, err := d.Bool()
|
|
s.Verified = bool(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"verified\"")
|
|
}
|
|
case "created_at":
|
|
requiredBitSet[0] |= 1 << 4
|
|
if err := func() error {
|
|
v, err := json.DecodeDateTime(d)
|
|
s.CreatedAt = v
|
|
if 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 UserCreate")
|
|
}
|
|
// Validate required fields.
|
|
var failures []validate.FieldError
|
|
for i, mask := range [1]uint8{
|
|
0b00011111,
|
|
} {
|
|
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("name")
|
|
e.Str(s.Name)
|
|
}
|
|
{
|
|
|
|
e.FieldStart("email")
|
|
e.Str(s.Email)
|
|
}
|
|
{
|
|
|
|
e.FieldStart("verified")
|
|
e.Bool(s.Verified)
|
|
}
|
|
{
|
|
|
|
e.FieldStart("created_at")
|
|
json.EncodeDateTime(e, s.CreatedAt)
|
|
}
|
|
}
|
|
|
|
var jsonFieldsNameOfUserList = [5]string{
|
|
0: "id",
|
|
1: "name",
|
|
2: "email",
|
|
3: "verified",
|
|
4: "created_at",
|
|
}
|
|
|
|
// 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 "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\"")
|
|
}
|
|
case "email":
|
|
requiredBitSet[0] |= 1 << 2
|
|
if err := func() error {
|
|
v, err := d.Str()
|
|
s.Email = string(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"email\"")
|
|
}
|
|
case "verified":
|
|
requiredBitSet[0] |= 1 << 3
|
|
if err := func() error {
|
|
v, err := d.Bool()
|
|
s.Verified = bool(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"verified\"")
|
|
}
|
|
case "created_at":
|
|
requiredBitSet[0] |= 1 << 4
|
|
if err := func() error {
|
|
v, err := json.DecodeDateTime(d)
|
|
s.CreatedAt = v
|
|
if 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 UserList")
|
|
}
|
|
// Validate required fields.
|
|
var failures []validate.FieldError
|
|
for i, mask := range [1]uint8{
|
|
0b00011111,
|
|
} {
|
|
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 *UserOwnerList) Encode(e *jx.Encoder) {
|
|
e.ObjStart()
|
|
s.encodeFields(e)
|
|
e.ObjEnd()
|
|
}
|
|
|
|
// encodeFields encodes fields.
|
|
func (s *UserOwnerList) encodeFields(e *jx.Encoder) {
|
|
{
|
|
|
|
e.FieldStart("id")
|
|
e.Int(s.ID)
|
|
}
|
|
{
|
|
|
|
e.FieldStart("created_at")
|
|
json.EncodeDateTime(e, s.CreatedAt)
|
|
}
|
|
}
|
|
|
|
var jsonFieldsNameOfUserOwnerList = [2]string{
|
|
0: "id",
|
|
1: "created_at",
|
|
}
|
|
|
|
// Decode decodes UserOwnerList from json.
|
|
func (s *UserOwnerList) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode UserOwnerList 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 "created_at":
|
|
requiredBitSet[0] |= 1 << 1
|
|
if err := func() error {
|
|
v, err := json.DecodeDateTime(d)
|
|
s.CreatedAt = v
|
|
if 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 UserOwnerList")
|
|
}
|
|
// 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(jsonFieldsNameOfUserOwnerList) {
|
|
name = jsonFieldsNameOfUserOwnerList[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 *UserOwnerList) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *UserOwnerList) 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("name")
|
|
e.Str(s.Name)
|
|
}
|
|
{
|
|
|
|
e.FieldStart("email")
|
|
e.Str(s.Email)
|
|
}
|
|
{
|
|
|
|
e.FieldStart("verified")
|
|
e.Bool(s.Verified)
|
|
}
|
|
{
|
|
|
|
e.FieldStart("created_at")
|
|
json.EncodeDateTime(e, s.CreatedAt)
|
|
}
|
|
}
|
|
|
|
var jsonFieldsNameOfUserRead = [5]string{
|
|
0: "id",
|
|
1: "name",
|
|
2: "email",
|
|
3: "verified",
|
|
4: "created_at",
|
|
}
|
|
|
|
// 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 "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\"")
|
|
}
|
|
case "email":
|
|
requiredBitSet[0] |= 1 << 2
|
|
if err := func() error {
|
|
v, err := d.Str()
|
|
s.Email = string(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"email\"")
|
|
}
|
|
case "verified":
|
|
requiredBitSet[0] |= 1 << 3
|
|
if err := func() error {
|
|
v, err := d.Bool()
|
|
s.Verified = bool(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"verified\"")
|
|
}
|
|
case "created_at":
|
|
requiredBitSet[0] |= 1 << 4
|
|
if err := func() error {
|
|
v, err := json.DecodeDateTime(d)
|
|
s.CreatedAt = v
|
|
if 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 UserRead")
|
|
}
|
|
// Validate required fields.
|
|
var failures []validate.FieldError
|
|
for i, mask := range [1]uint8{
|
|
0b00011111,
|
|
} {
|
|
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("name")
|
|
e.Str(s.Name)
|
|
}
|
|
{
|
|
|
|
e.FieldStart("email")
|
|
e.Str(s.Email)
|
|
}
|
|
{
|
|
|
|
e.FieldStart("verified")
|
|
e.Bool(s.Verified)
|
|
}
|
|
{
|
|
|
|
e.FieldStart("created_at")
|
|
json.EncodeDateTime(e, s.CreatedAt)
|
|
}
|
|
}
|
|
|
|
var jsonFieldsNameOfUserUpdate = [5]string{
|
|
0: "id",
|
|
1: "name",
|
|
2: "email",
|
|
3: "verified",
|
|
4: "created_at",
|
|
}
|
|
|
|
// 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 "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\"")
|
|
}
|
|
case "email":
|
|
requiredBitSet[0] |= 1 << 2
|
|
if err := func() error {
|
|
v, err := d.Str()
|
|
s.Email = string(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"email\"")
|
|
}
|
|
case "verified":
|
|
requiredBitSet[0] |= 1 << 3
|
|
if err := func() error {
|
|
v, err := d.Bool()
|
|
s.Verified = bool(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"verified\"")
|
|
}
|
|
case "created_at":
|
|
requiredBitSet[0] |= 1 << 4
|
|
if err := func() error {
|
|
v, err := json.DecodeDateTime(d)
|
|
s.CreatedAt = v
|
|
if 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 UserUpdate")
|
|
}
|
|
// Validate required fields.
|
|
var failures []validate.FieldError
|
|
for i, mask := range [1]uint8{
|
|
0b00011111,
|
|
} {
|
|
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)
|
|
}
|