ai/api
ai/api
1
0
Fork 0
Code
1124b851aa
api/ent/ogent/oas_json_gen.go
syui 1124b851aa
test count
2023-08-21 22:14:00 +09:00

8172 lines
165 KiB
Go
Raw Blame History

// 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.Skill.Set {
e.FieldStart("skill")
s.Skill.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.Count.Set {
e.FieldStart("count")
s.Count.Encode(e)
}
}
{
if s.Author.Set {
e.FieldStart("author")
s.Author.Encode(e)
}
}
{
if s.CreatedAt.Set {
e.FieldStart("created_at")
s.CreatedAt.Encode(e, json.EncodeDateTime)
}
}
}
var jsonFieldsNameOfCardCreate = [9]string{
0: "id",
1: "card",
2: "skill",
3: "status",
4: "cp",
5: "url",
6: "count",
7: "author",
8: "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 [2]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 "skill":
if err := func() error {
s.Skill.Reset()
if err := s.Skill.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"skill\"")
}
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 "count":
if err := func() error {
s.Count.Reset()
if err := s.Count.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"count\"")
}
case "author":
if err := func() error {
s.Author.Reset()
if err := s.Author.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"author\"")
}
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 [2]uint8{
0b00000001,
0b00000000,
} {
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.Skill.Set {
e.FieldStart("skill")
s.Skill.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.Count.Set {
e.FieldStart("count")
s.Count.Encode(e)
}
}
{
if s.Author.Set {
e.FieldStart("author")
s.Author.Encode(e)
}
}
{
if s.CreatedAt.Set {
e.FieldStart("created_at")
s.CreatedAt.Encode(e, json.EncodeDateTime)
}
}
}
var jsonFieldsNameOfCardList = [9]string{
0: "id",
1: "card",
2: "skill",
3: "status",
4: "cp",
5: "url",
6: "count",
7: "author",
8: "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 [2]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 "skill":
if err := func() error {
s.Skill.Reset()
if err := s.Skill.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"skill\"")
}
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 "count":
if err := func() error {
s.Count.Reset()
if err := s.Count.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"count\"")
}
case "author":
if err := func() error {
s.Author.Reset()
if err := s.Author.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"author\"")
}
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 [2]uint8{
0b00000001,
0b00000000,
} {
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.Did.Set {
e.FieldStart("did")
s.Did.Encode(e)
}
}
{
if s.Member.Set {
e.FieldStart("member")
s.Member.Encode(e)
}
}
{
if s.Book.Set {
e.FieldStart("book")
s.Book.Encode(e)
}
}
{
if s.Manga.Set {
e.FieldStart("manga")
s.Manga.Encode(e)
}
}
{
if s.Badge.Set {
e.FieldStart("badge")
s.Badge.Encode(e)
}
}
{
if s.Bsky.Set {
e.FieldStart("bsky")
s.Bsky.Encode(e)
}
}
{
if s.Mastodon.Set {
e.FieldStart("mastodon")
s.Mastodon.Encode(e)
}
}
{
if s.Delete.Set {
e.FieldStart("delete")
s.Delete.Encode(e)
}
}
{
if s.Handle.Set {
e.FieldStart("handle")
s.Handle.Encode(e)
}
}
{
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.RaidAt.Set {
e.FieldStart("raid_at")
s.RaidAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.EggAt.Set {
e.FieldStart("egg_at")
s.EggAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.Luck.Set {
e.FieldStart("luck")
s.Luck.Encode(e)
}
}
{
if s.LuckAt.Set {
e.FieldStart("luck_at")
s.LuckAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.Like.Set {
e.FieldStart("like")
s.Like.Encode(e)
}
}
{
if s.LikeRank.Set {
e.FieldStart("like_rank")
s.LikeRank.Encode(e)
}
}
{
if s.LikeAt.Set {
e.FieldStart("like_at")
s.LikeAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.Fav.Set {
e.FieldStart("fav")
s.Fav.Encode(e)
}
}
{
if s.Ten.Set {
e.FieldStart("ten")
s.Ten.Encode(e)
}
}
{
if s.TenSu.Set {
e.FieldStart("ten_su")
s.TenSu.Encode(e)
}
}
{
if s.TenKai.Set {
e.FieldStart("ten_kai")
s.TenKai.Encode(e)
}
}
{
if s.Aiten.Set {
e.FieldStart("aiten")
s.Aiten.Encode(e)
}
}
{
if s.TenCard.Set {
e.FieldStart("ten_card")
s.TenCard.Encode(e)
}
}
{
if s.TenDelete.Set {
e.FieldStart("ten_delete")
s.TenDelete.Encode(e)
}
}
{
if s.TenPost.Set {
e.FieldStart("ten_post")
s.TenPost.Encode(e)
}
}
{
if s.TenGet.Set {
e.FieldStart("ten_get")
s.TenGet.Encode(e)
}
}
{
if s.TenAt.Set {
e.FieldStart("ten_at")
s.TenAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.Next.Set {
e.FieldStart("next")
s.Next.Encode(e)
}
}
}
var jsonFieldsNameOfCardOwnerRead = [31]string{
0: "id",
1: "username",
2: "did",
3: "member",
4: "book",
5: "manga",
6: "badge",
7: "bsky",
8: "mastodon",
9: "delete",
10: "handle",
11: "created_at",
12: "updated_at",
13: "raid_at",
14: "egg_at",
15: "luck",
16: "luck_at",
17: "like",
18: "like_rank",
19: "like_at",
20: "fav",
21: "ten",
22: "ten_su",
23: "ten_kai",
24: "aiten",
25: "ten_card",
26: "ten_delete",
27: "ten_post",
28: "ten_get",
29: "ten_at",
30: "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 [4]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 "did":
if err := func() error {
s.Did.Reset()
if err := s.Did.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"did\"")
}
case "member":
if err := func() error {
s.Member.Reset()
if err := s.Member.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"member\"")
}
case "book":
if err := func() error {
s.Book.Reset()
if err := s.Book.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"book\"")
}
case "manga":
if err := func() error {
s.Manga.Reset()
if err := s.Manga.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"manga\"")
}
case "badge":
if err := func() error {
s.Badge.Reset()
if err := s.Badge.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"badge\"")
}
case "bsky":
if err := func() error {
s.Bsky.Reset()
if err := s.Bsky.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"bsky\"")
}
case "mastodon":
if err := func() error {
s.Mastodon.Reset()
if err := s.Mastodon.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"mastodon\"")
}
case "delete":
if err := func() error {
s.Delete.Reset()
if err := s.Delete.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"delete\"")
}
case "handle":
if err := func() error {
s.Handle.Reset()
if err := s.Handle.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"handle\"")
}
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 "raid_at":
if err := func() error {
s.RaidAt.Reset()
if err := s.RaidAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"raid_at\"")
}
case "egg_at":
if err := func() error {
s.EggAt.Reset()
if err := s.EggAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"egg_at\"")
}
case "luck":
if err := func() error {
s.Luck.Reset()
if err := s.Luck.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"luck\"")
}
case "luck_at":
if err := func() error {
s.LuckAt.Reset()
if err := s.LuckAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"luck_at\"")
}
case "like":
if err := func() error {
s.Like.Reset()
if err := s.Like.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"like\"")
}
case "like_rank":
if err := func() error {
s.LikeRank.Reset()
if err := s.LikeRank.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"like_rank\"")
}
case "like_at":
if err := func() error {
s.LikeAt.Reset()
if err := s.LikeAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"like_at\"")
}
case "fav":
if err := func() error {
s.Fav.Reset()
if err := s.Fav.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"fav\"")
}
case "ten":
if err := func() error {
s.Ten.Reset()
if err := s.Ten.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten\"")
}
case "ten_su":
if err := func() error {
s.TenSu.Reset()
if err := s.TenSu.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_su\"")
}
case "ten_kai":
if err := func() error {
s.TenKai.Reset()
if err := s.TenKai.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_kai\"")
}
case "aiten":
if err := func() error {
s.Aiten.Reset()
if err := s.Aiten.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"aiten\"")
}
case "ten_card":
if err := func() error {
s.TenCard.Reset()
if err := s.TenCard.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_card\"")
}
case "ten_delete":
if err := func() error {
s.TenDelete.Reset()
if err := s.TenDelete.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_delete\"")
}
case "ten_post":
if err := func() error {
s.TenPost.Reset()
if err := s.TenPost.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_post\"")
}
case "ten_get":
if err := func() error {
s.TenGet.Reset()
if err := s.TenGet.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_get\"")
}
case "ten_at":
if err := func() error {
s.TenAt.Reset()
if err := s.TenAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_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 [4]uint8{
0b00000011,
0b00000000,
0b00000000,
0b00000000,
} {
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.Skill.Set {
e.FieldStart("skill")
s.Skill.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.Count.Set {
e.FieldStart("count")
s.Count.Encode(e)
}
}
{
if s.Author.Set {
e.FieldStart("author")
s.Author.Encode(e)
}
}
{
if s.CreatedAt.Set {
e.FieldStart("created_at")
s.CreatedAt.Encode(e, json.EncodeDateTime)
}
}
}
var jsonFieldsNameOfCardRead = [9]string{
0: "id",
1: "card",
2: "skill",
3: "status",
4: "cp",
5: "url",
6: "count",
7: "author",
8: "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 [2]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 "skill":
if err := func() error {
s.Skill.Reset()
if err := s.Skill.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"skill\"")
}
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 "count":
if err := func() error {
s.Count.Reset()
if err := s.Count.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"count\"")
}
case "author":
if err := func() error {
s.Author.Reset()
if err := s.Author.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"author\"")
}
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 [2]uint8{
0b00000001,
0b00000000,
} {
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.Skill.Set {
e.FieldStart("skill")
s.Skill.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.Count.Set {
e.FieldStart("count")
s.Count.Encode(e)
}
}
{
if s.Author.Set {
e.FieldStart("author")
s.Author.Encode(e)
}
}
{
if s.CreatedAt.Set {
e.FieldStart("created_at")
s.CreatedAt.Encode(e, json.EncodeDateTime)
}
}
}
var jsonFieldsNameOfCardUpdate = [9]string{
0: "id",
1: "card",
2: "skill",
3: "status",
4: "cp",
5: "url",
6: "count",
7: "author",
8: "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 [2]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 "skill":
if err := func() error {
s.Skill.Reset()
if err := s.Skill.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"skill\"")
}
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 "count":
if err := func() error {
s.Count.Reset()
if err := s.Count.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"count\"")
}
case "author":
if err := func() error {
s.Author.Reset()
if err := s.Author.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"author\"")
}
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 [2]uint8{
0b00000001,
0b00000000,
} {
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) {
{
e.FieldStart("password")
e.Str(s.Password)
}
{
if s.Card.Set {
e.FieldStart("card")
s.Card.Encode(e)
}
}
{
if s.Skill.Set {
e.FieldStart("skill")
s.Skill.Encode(e)
}
}
{
if s.Status.Set {
e.FieldStart("status")
s.Status.Encode(e)
}
}
{
if s.Token.Set {
e.FieldStart("token")
s.Token.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.Count.Set {
e.FieldStart("count")
s.Count.Encode(e)
}
}
{
if s.Author.Set {
e.FieldStart("author")
s.Author.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 = [11]string{
0: "password",
1: "card",
2: "skill",
3: "status",
4: "token",
5: "cp",
6: "url",
7: "count",
8: "author",
9: "created_at",
10: "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 [2]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "password":
requiredBitSet[0] |= 1 << 0
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 "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 "skill":
if err := func() error {
s.Skill.Reset()
if err := s.Skill.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"skill\"")
}
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 "token":
if err := func() error {
s.Token.Reset()
if err := s.Token.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"token\"")
}
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 "count":
if err := func() error {
s.Count.Reset()
if err := s.Count.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"count\"")
}
case "author":
if err := func() error {
s.Author.Reset()
if err := s.Author.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"author\"")
}
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[1] |= 1 << 2
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 [2]uint8{
0b00000001,
0b00000100,
} {
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)
}
{
e.FieldStart("password")
e.Str(s.Password)
}
{
if s.Users != nil {
e.FieldStart("users")
e.ArrStart()
for _, elem := range s.Users {
e.Int(elem)
}
e.ArrEnd()
}
}
}
var jsonFieldsNameOfCreateGroupReq = [3]string{
0: "name",
1: "password",
2: "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 "password":
requiredBitSet[0] |= 1 << 1
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 "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{
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(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.Did.Set {
e.FieldStart("did")
s.Did.Encode(e)
}
}
{
if s.Member.Set {
e.FieldStart("member")
s.Member.Encode(e)
}
}
{
if s.Book.Set {
e.FieldStart("book")
s.Book.Encode(e)
}
}
{
if s.Manga.Set {
e.FieldStart("manga")
s.Manga.Encode(e)
}
}
{
if s.Badge.Set {
e.FieldStart("badge")
s.Badge.Encode(e)
}
}
{
if s.Bsky.Set {
e.FieldStart("bsky")
s.Bsky.Encode(e)
}
}
{
if s.Mastodon.Set {
e.FieldStart("mastodon")
s.Mastodon.Encode(e)
}
}
{
if s.Delete.Set {
e.FieldStart("delete")
s.Delete.Encode(e)
}
}
{
if s.Handle.Set {
e.FieldStart("handle")
s.Handle.Encode(e)
}
}
{
if s.Token.Set {
e.FieldStart("token")
s.Token.Encode(e)
}
}
{
e.FieldStart("password")
e.Str(s.Password)
}
{
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.RaidAt.Set {
e.FieldStart("raid_at")
s.RaidAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.EggAt.Set {
e.FieldStart("egg_at")
s.EggAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.Luck.Set {
e.FieldStart("luck")
s.Luck.Encode(e)
}
}
{
if s.LuckAt.Set {
e.FieldStart("luck_at")
s.LuckAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.Like.Set {
e.FieldStart("like")
s.Like.Encode(e)
}
}
{
if s.LikeRank.Set {
e.FieldStart("like_rank")
s.LikeRank.Encode(e)
}
}
{
if s.LikeAt.Set {
e.FieldStart("like_at")
s.LikeAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.Fav.Set {
e.FieldStart("fav")
s.Fav.Encode(e)
}
}
{
if s.Ten.Set {
e.FieldStart("ten")
s.Ten.Encode(e)
}
}
{
if s.TenSu.Set {
e.FieldStart("ten_su")
s.TenSu.Encode(e)
}
}
{
if s.TenKai.Set {
e.FieldStart("ten_kai")
s.TenKai.Encode(e)
}
}
{
if s.Aiten.Set {
e.FieldStart("aiten")
s.Aiten.Encode(e)
}
}
{
if s.TenCard.Set {
e.FieldStart("ten_card")
s.TenCard.Encode(e)
}
}
{
if s.TenDelete.Set {
e.FieldStart("ten_delete")
s.TenDelete.Encode(e)
}
}
{
if s.TenPost.Set {
e.FieldStart("ten_post")
s.TenPost.Encode(e)
}
}
{
if s.TenGet.Set {
e.FieldStart("ten_get")
s.TenGet.Encode(e)
}
}
{
if s.TenAt.Set {
e.FieldStart("ten_at")
s.TenAt.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 = [33]string{
0: "username",
1: "did",
2: "member",
3: "book",
4: "manga",
5: "badge",
6: "bsky",
7: "mastodon",
8: "delete",
9: "handle",
10: "token",
11: "password",
12: "created_at",
13: "updated_at",
14: "raid_at",
15: "egg_at",
16: "luck",
17: "luck_at",
18: "like",
19: "like_rank",
20: "like_at",
21: "fav",
22: "ten",
23: "ten_su",
24: "ten_kai",
25: "aiten",
26: "ten_card",
27: "ten_delete",
28: "ten_post",
29: "ten_get",
30: "ten_at",
31: "next",
32: "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 [5]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 "did":
if err := func() error {
s.Did.Reset()
if err := s.Did.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"did\"")
}
case "member":
if err := func() error {
s.Member.Reset()
if err := s.Member.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"member\"")
}
case "book":
if err := func() error {
s.Book.Reset()
if err := s.Book.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"book\"")
}
case "manga":
if err := func() error {
s.Manga.Reset()
if err := s.Manga.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"manga\"")
}
case "badge":
if err := func() error {
s.Badge.Reset()
if err := s.Badge.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"badge\"")
}
case "bsky":
if err := func() error {
s.Bsky.Reset()
if err := s.Bsky.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"bsky\"")
}
case "mastodon":
if err := func() error {
s.Mastodon.Reset()
if err := s.Mastodon.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"mastodon\"")
}
case "delete":
if err := func() error {
s.Delete.Reset()
if err := s.Delete.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"delete\"")
}
case "handle":
if err := func() error {
s.Handle.Reset()
if err := s.Handle.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"handle\"")
}
case "token":
if err := func() error {
s.Token.Reset()
if err := s.Token.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"token\"")
}
case "password":
requiredBitSet[1] |= 1 << 3
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 "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 "raid_at":
if err := func() error {
s.RaidAt.Reset()
if err := s.RaidAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"raid_at\"")
}
case "egg_at":
if err := func() error {
s.EggAt.Reset()
if err := s.EggAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"egg_at\"")
}
case "luck":
if err := func() error {
s.Luck.Reset()
if err := s.Luck.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"luck\"")
}
case "luck_at":
if err := func() error {
s.LuckAt.Reset()
if err := s.LuckAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"luck_at\"")
}
case "like":
if err := func() error {
s.Like.Reset()
if err := s.Like.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"like\"")
}
case "like_rank":
if err := func() error {
s.LikeRank.Reset()
if err := s.LikeRank.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"like_rank\"")
}
case "like_at":
if err := func() error {
s.LikeAt.Reset()
if err := s.LikeAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"like_at\"")
}
case "fav":
if err := func() error {
s.Fav.Reset()
if err := s.Fav.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"fav\"")
}
case "ten":
if err := func() error {
s.Ten.Reset()
if err := s.Ten.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten\"")
}
case "ten_su":
if err := func() error {
s.TenSu.Reset()
if err := s.TenSu.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_su\"")
}
case "ten_kai":
if err := func() error {
s.TenKai.Reset()
if err := s.TenKai.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_kai\"")
}
case "aiten":
if err := func() error {
s.Aiten.Reset()
if err := s.Aiten.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"aiten\"")
}
case "ten_card":
if err := func() error {
s.TenCard.Reset()
if err := s.TenCard.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_card\"")
}
case "ten_delete":
if err := func() error {
s.TenDelete.Reset()
if err := s.TenDelete.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_delete\"")
}
case "ten_post":
if err := func() error {
s.TenPost.Reset()
if err := s.TenPost.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_post\"")
}
case "ten_get":
if err := func() error {
s.TenGet.Reset()
if err := s.TenGet.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_get\"")
}
case "ten_at":
if err := func() error {
s.TenAt.Reset()
if err := s.TenAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_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 [5]uint8{
0b00000001,
0b00001000,
0b00000000,
0b00000000,
0b00000000,
} {
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.Did.Set {
e.FieldStart("did")
s.Did.Encode(e)
}
}
{
if s.Member.Set {
e.FieldStart("member")
s.Member.Encode(e)
}
}
{
if s.Book.Set {
e.FieldStart("book")
s.Book.Encode(e)
}
}
{
if s.Manga.Set {
e.FieldStart("manga")
s.Manga.Encode(e)
}
}
{
if s.Badge.Set {
e.FieldStart("badge")
s.Badge.Encode(e)
}
}
{
if s.Bsky.Set {
e.FieldStart("bsky")
s.Bsky.Encode(e)
}
}
{
if s.Mastodon.Set {
e.FieldStart("mastodon")
s.Mastodon.Encode(e)
}
}
{
if s.Delete.Set {
e.FieldStart("delete")
s.Delete.Encode(e)
}
}
{
if s.Handle.Set {
e.FieldStart("handle")
s.Handle.Encode(e)
}
}
{
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.RaidAt.Set {
e.FieldStart("raid_at")
s.RaidAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.EggAt.Set {
e.FieldStart("egg_at")
s.EggAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.Luck.Set {
e.FieldStart("luck")
s.Luck.Encode(e)
}
}
{
if s.LuckAt.Set {
e.FieldStart("luck_at")
s.LuckAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.Like.Set {
e.FieldStart("like")
s.Like.Encode(e)
}
}
{
if s.LikeRank.Set {
e.FieldStart("like_rank")
s.LikeRank.Encode(e)
}
}
{
if s.LikeAt.Set {
e.FieldStart("like_at")
s.LikeAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.Fav.Set {
e.FieldStart("fav")
s.Fav.Encode(e)
}
}
{
if s.Ten.Set {
e.FieldStart("ten")
s.Ten.Encode(e)
}
}
{
if s.TenSu.Set {
e.FieldStart("ten_su")
s.TenSu.Encode(e)
}
}
{
if s.TenKai.Set {
e.FieldStart("ten_kai")
s.TenKai.Encode(e)
}
}
{
if s.Aiten.Set {
e.FieldStart("aiten")
s.Aiten.Encode(e)
}
}
{
if s.TenCard.Set {
e.FieldStart("ten_card")
s.TenCard.Encode(e)
}
}
{
if s.TenDelete.Set {
e.FieldStart("ten_delete")
s.TenDelete.Encode(e)
}
}
{
if s.TenPost.Set {
e.FieldStart("ten_post")
s.TenPost.Encode(e)
}
}
{
if s.TenGet.Set {
e.FieldStart("ten_get")
s.TenGet.Encode(e)
}
}
{
if s.TenAt.Set {
e.FieldStart("ten_at")
s.TenAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.Next.Set {
e.FieldStart("next")
s.Next.Encode(e)
}
}
}
var jsonFieldsNameOfGroupUsersList = [31]string{
0: "id",
1: "username",
2: "did",
3: "member",
4: "book",
5: "manga",
6: "badge",
7: "bsky",
8: "mastodon",
9: "delete",
10: "handle",
11: "created_at",
12: "updated_at",
13: "raid_at",
14: "egg_at",
15: "luck",
16: "luck_at",
17: "like",
18: "like_rank",
19: "like_at",
20: "fav",
21: "ten",
22: "ten_su",
23: "ten_kai",
24: "aiten",
25: "ten_card",
26: "ten_delete",
27: "ten_post",
28: "ten_get",
29: "ten_at",
30: "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 [4]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 "did":
if err := func() error {
s.Did.Reset()
if err := s.Did.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"did\"")
}
case "member":
if err := func() error {
s.Member.Reset()
if err := s.Member.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"member\"")
}
case "book":
if err := func() error {
s.Book.Reset()
if err := s.Book.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"book\"")
}
case "manga":
if err := func() error {
s.Manga.Reset()
if err := s.Manga.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"manga\"")
}
case "badge":
if err := func() error {
s.Badge.Reset()
if err := s.Badge.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"badge\"")
}
case "bsky":
if err := func() error {
s.Bsky.Reset()
if err := s.Bsky.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"bsky\"")
}
case "mastodon":
if err := func() error {
s.Mastodon.Reset()
if err := s.Mastodon.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"mastodon\"")
}
case "delete":
if err := func() error {
s.Delete.Reset()
if err := s.Delete.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"delete\"")
}
case "handle":
if err := func() error {
s.Handle.Reset()
if err := s.Handle.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"handle\"")
}
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 "raid_at":
if err := func() error {
s.RaidAt.Reset()
if err := s.RaidAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"raid_at\"")
}
case "egg_at":
if err := func() error {
s.EggAt.Reset()
if err := s.EggAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"egg_at\"")
}
case "luck":
if err := func() error {
s.Luck.Reset()
if err := s.Luck.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"luck\"")
}
case "luck_at":
if err := func() error {
s.LuckAt.Reset()
if err := s.LuckAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"luck_at\"")
}
case "like":
if err := func() error {
s.Like.Reset()
if err := s.Like.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"like\"")
}
case "like_rank":
if err := func() error {
s.LikeRank.Reset()
if err := s.LikeRank.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"like_rank\"")
}
case "like_at":
if err := func() error {
s.LikeAt.Reset()
if err := s.LikeAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"like_at\"")
}
case "fav":
if err := func() error {
s.Fav.Reset()
if err := s.Fav.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"fav\"")
}
case "ten":
if err := func() error {
s.Ten.Reset()
if err := s.Ten.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten\"")
}
case "ten_su":
if err := func() error {
s.TenSu.Reset()
if err := s.TenSu.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_su\"")
}
case "ten_kai":
if err := func() error {
s.TenKai.Reset()
if err := s.TenKai.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_kai\"")
}
case "aiten":
if err := func() error {
s.Aiten.Reset()
if err := s.Aiten.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"aiten\"")
}
case "ten_card":
if err := func() error {
s.TenCard.Reset()
if err := s.TenCard.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_card\"")
}
case "ten_delete":
if err := func() error {
s.TenDelete.Reset()
if err := s.TenDelete.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_delete\"")
}
case "ten_post":
if err := func() error {
s.TenPost.Reset()
if err := s.TenPost.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_post\"")
}
case "ten_get":
if err := func() error {
s.TenGet.Reset()
if err := s.TenGet.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_get\"")
}
case "ten_at":
if err := func() error {
s.TenAt.Reset()
if err := s.TenAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_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 [4]uint8{
0b00000011,
0b00000000,
0b00000000,
0b00000000,
} {
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 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 *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.Card.Set {
e.FieldStart("card")
s.Card.Encode(e)
}
}
{
if s.Skill.Set {
e.FieldStart("skill")
s.Skill.Encode(e)
}
}
{
if s.Status.Set {
e.FieldStart("status")
s.Status.Encode(e)
}
}
{
if s.Token.Set {
e.FieldStart("token")
s.Token.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.Count.Set {
e.FieldStart("count")
s.Count.Encode(e)
}
}
{
if s.Author.Set {
e.FieldStart("author")
s.Author.Encode(e)
}
}
{
if s.Owner.Set {
e.FieldStart("owner")
s.Owner.Encode(e)
}
}
}
var jsonFieldsNameOfUpdateCardReq = [9]string{
0: "card",
1: "skill",
2: "status",
3: "token",
4: "cp",
5: "url",
6: "count",
7: "author",
8: "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 "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 "skill":
if err := func() error {
s.Skill.Reset()
if err := s.Skill.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"skill\"")
}
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 "token":
if err := func() error {
s.Token.Reset()
if err := s.Token.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"token\"")
}
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 "count":
if err := func() error {
s.Count.Reset()
if err := s.Count.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"count\"")
}
case "author":
if err := func() error {
s.Author.Reset()
if err := s.Author.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"author\"")
}
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.Did.Set {
e.FieldStart("did")
s.Did.Encode(e)
}
}
{
if s.Member.Set {
e.FieldStart("member")
s.Member.Encode(e)
}
}
{
if s.Book.Set {
e.FieldStart("book")
s.Book.Encode(e)
}
}
{
if s.Manga.Set {
e.FieldStart("manga")
s.Manga.Encode(e)
}
}
{
if s.Badge.Set {
e.FieldStart("badge")
s.Badge.Encode(e)
}
}
{
if s.Bsky.Set {
e.FieldStart("bsky")
s.Bsky.Encode(e)
}
}
{
if s.Mastodon.Set {
e.FieldStart("mastodon")
s.Mastodon.Encode(e)
}
}
{
if s.Delete.Set {
e.FieldStart("delete")
s.Delete.Encode(e)
}
}
{
if s.Handle.Set {
e.FieldStart("handle")
s.Handle.Encode(e)
}
}
{
if s.Token.Set {
e.FieldStart("token")
s.Token.Encode(e)
}
}
{
if s.UpdatedAt.Set {
e.FieldStart("updated_at")
s.UpdatedAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.RaidAt.Set {
e.FieldStart("raid_at")
s.RaidAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.EggAt.Set {
e.FieldStart("egg_at")
s.EggAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.Luck.Set {
e.FieldStart("luck")
s.Luck.Encode(e)
}
}
{
if s.LuckAt.Set {
e.FieldStart("luck_at")
s.LuckAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.Like.Set {
e.FieldStart("like")
s.Like.Encode(e)
}
}
{
if s.LikeRank.Set {
e.FieldStart("like_rank")
s.LikeRank.Encode(e)
}
}
{
if s.LikeAt.Set {
e.FieldStart("like_at")
s.LikeAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.Fav.Set {
e.FieldStart("fav")
s.Fav.Encode(e)
}
}
{
if s.Ten.Set {
e.FieldStart("ten")
s.Ten.Encode(e)
}
}
{
if s.TenSu.Set {
e.FieldStart("ten_su")
s.TenSu.Encode(e)
}
}
{
if s.TenKai.Set {
e.FieldStart("ten_kai")
s.TenKai.Encode(e)
}
}
{
if s.Aiten.Set {
e.FieldStart("aiten")
s.Aiten.Encode(e)
}
}
{
if s.TenCard.Set {
e.FieldStart("ten_card")
s.TenCard.Encode(e)
}
}
{
if s.TenDelete.Set {
e.FieldStart("ten_delete")
s.TenDelete.Encode(e)
}
}
{
if s.TenPost.Set {
e.FieldStart("ten_post")
s.TenPost.Encode(e)
}
}
{
if s.TenGet.Set {
e.FieldStart("ten_get")
s.TenGet.Encode(e)
}
}
{
if s.TenAt.Set {
e.FieldStart("ten_at")
s.TenAt.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 = [30]string{
0: "did",
1: "member",
2: "book",
3: "manga",
4: "badge",
5: "bsky",
6: "mastodon",
7: "delete",
8: "handle",
9: "token",
10: "updated_at",
11: "raid_at",
12: "egg_at",
13: "luck",
14: "luck_at",
15: "like",
16: "like_rank",
17: "like_at",
18: "fav",
19: "ten",
20: "ten_su",
21: "ten_kai",
22: "aiten",
23: "ten_card",
24: "ten_delete",
25: "ten_post",
26: "ten_get",
27: "ten_at",
28: "next",
29: "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 "did":
if err := func() error {
s.Did.Reset()
if err := s.Did.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"did\"")
}
case "member":
if err := func() error {
s.Member.Reset()
if err := s.Member.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"member\"")
}
case "book":
if err := func() error {
s.Book.Reset()
if err := s.Book.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"book\"")
}
case "manga":
if err := func() error {
s.Manga.Reset()
if err := s.Manga.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"manga\"")
}
case "badge":
if err := func() error {
s.Badge.Reset()
if err := s.Badge.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"badge\"")
}
case "bsky":
if err := func() error {
s.Bsky.Reset()
if err := s.Bsky.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"bsky\"")
}
case "mastodon":
if err := func() error {
s.Mastodon.Reset()
if err := s.Mastodon.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"mastodon\"")
}
case "delete":
if err := func() error {
s.Delete.Reset()
if err := s.Delete.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"delete\"")
}
case "handle":
if err := func() error {
s.Handle.Reset()
if err := s.Handle.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"handle\"")
}
case "token":
if err := func() error {
s.Token.Reset()
if err := s.Token.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"token\"")
}
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 "raid_at":
if err := func() error {
s.RaidAt.Reset()
if err := s.RaidAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"raid_at\"")
}
case "egg_at":
if err := func() error {
s.EggAt.Reset()
if err := s.EggAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"egg_at\"")
}
case "luck":
if err := func() error {
s.Luck.Reset()
if err := s.Luck.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"luck\"")
}
case "luck_at":
if err := func() error {
s.LuckAt.Reset()
if err := s.LuckAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"luck_at\"")
}
case "like":
if err := func() error {
s.Like.Reset()
if err := s.Like.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"like\"")
}
case "like_rank":
if err := func() error {
s.LikeRank.Reset()
if err := s.LikeRank.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"like_rank\"")
}
case "like_at":
if err := func() error {
s.LikeAt.Reset()
if err := s.LikeAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"like_at\"")
}
case "fav":
if err := func() error {
s.Fav.Reset()
if err := s.Fav.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"fav\"")
}
case "ten":
if err := func() error {
s.Ten.Reset()
if err := s.Ten.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten\"")
}
case "ten_su":
if err := func() error {
s.TenSu.Reset()
if err := s.TenSu.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_su\"")
}
case "ten_kai":
if err := func() error {
s.TenKai.Reset()
if err := s.TenKai.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_kai\"")
}
case "aiten":
if err := func() error {
s.Aiten.Reset()
if err := s.Aiten.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"aiten\"")
}
case "ten_card":
if err := func() error {
s.TenCard.Reset()
if err := s.TenCard.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_card\"")
}
case "ten_delete":
if err := func() error {
s.TenDelete.Reset()
if err := s.TenDelete.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_delete\"")
}
case "ten_post":
if err := func() error {
s.TenPost.Reset()
if err := s.TenPost.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_post\"")
}
case "ten_get":
if err := func() error {
s.TenGet.Reset()
if err := s.TenGet.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_get\"")
}
case "ten_at":
if err := func() error {
s.TenAt.Reset()
if err := s.TenAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_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.Skill.Set {
e.FieldStart("skill")
s.Skill.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.Count.Set {
e.FieldStart("count")
s.Count.Encode(e)
}
}
{
if s.Author.Set {
e.FieldStart("author")
s.Author.Encode(e)
}
}
{
if s.CreatedAt.Set {
e.FieldStart("created_at")
s.CreatedAt.Encode(e, json.EncodeDateTime)
}
}
}
var jsonFieldsNameOfUserCardList = [9]string{
0: "id",
1: "card",
2: "skill",
3: "status",
4: "cp",
5: "url",
6: "count",
7: "author",
8: "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 [2]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 "skill":
if err := func() error {
s.Skill.Reset()
if err := s.Skill.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"skill\"")
}
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 "count":
if err := func() error {
s.Count.Reset()
if err := s.Count.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"count\"")
}
case "author":
if err := func() error {
s.Author.Reset()
if err := s.Author.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"author\"")
}
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 [2]uint8{
0b00000001,
0b00000000,
} {
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.Did.Set {
e.FieldStart("did")
s.Did.Encode(e)
}
}
{
if s.Member.Set {
e.FieldStart("member")
s.Member.Encode(e)
}
}
{
if s.Book.Set {
e.FieldStart("book")
s.Book.Encode(e)
}
}
{
if s.Manga.Set {
e.FieldStart("manga")
s.Manga.Encode(e)
}
}
{
if s.Badge.Set {
e.FieldStart("badge")
s.Badge.Encode(e)
}
}
{
if s.Bsky.Set {
e.FieldStart("bsky")
s.Bsky.Encode(e)
}
}
{
if s.Mastodon.Set {
e.FieldStart("mastodon")
s.Mastodon.Encode(e)
}
}
{
if s.Delete.Set {
e.FieldStart("delete")
s.Delete.Encode(e)
}
}
{
if s.Handle.Set {
e.FieldStart("handle")
s.Handle.Encode(e)
}
}
{
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.RaidAt.Set {
e.FieldStart("raid_at")
s.RaidAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.EggAt.Set {
e.FieldStart("egg_at")
s.EggAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.Luck.Set {
e.FieldStart("luck")
s.Luck.Encode(e)
}
}
{
if s.LuckAt.Set {
e.FieldStart("luck_at")
s.LuckAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.Like.Set {
e.FieldStart("like")
s.Like.Encode(e)
}
}
{
if s.LikeRank.Set {
e.FieldStart("like_rank")
s.LikeRank.Encode(e)
}
}
{
if s.LikeAt.Set {
e.FieldStart("like_at")
s.LikeAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.Fav.Set {
e.FieldStart("fav")
s.Fav.Encode(e)
}
}
{
if s.Ten.Set {
e.FieldStart("ten")
s.Ten.Encode(e)
}
}
{
if s.TenSu.Set {
e.FieldStart("ten_su")
s.TenSu.Encode(e)
}
}
{
if s.TenKai.Set {
e.FieldStart("ten_kai")
s.TenKai.Encode(e)
}
}
{
if s.Aiten.Set {
e.FieldStart("aiten")
s.Aiten.Encode(e)
}
}
{
if s.TenCard.Set {
e.FieldStart("ten_card")
s.TenCard.Encode(e)
}
}
{
if s.TenDelete.Set {
e.FieldStart("ten_delete")
s.TenDelete.Encode(e)
}
}
{
if s.TenPost.Set {
e.FieldStart("ten_post")
s.TenPost.Encode(e)
}
}
{
if s.TenGet.Set {
e.FieldStart("ten_get")
s.TenGet.Encode(e)
}
}
{
if s.TenAt.Set {
e.FieldStart("ten_at")
s.TenAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.Next.Set {
e.FieldStart("next")
s.Next.Encode(e)
}
}
}
var jsonFieldsNameOfUserCreate = [31]string{
0: "id",
1: "username",
2: "did",
3: "member",
4: "book",
5: "manga",
6: "badge",
7: "bsky",
8: "mastodon",
9: "delete",
10: "handle",
11: "created_at",
12: "updated_at",
13: "raid_at",
14: "egg_at",
15: "luck",
16: "luck_at",
17: "like",
18: "like_rank",
19: "like_at",
20: "fav",
21: "ten",
22: "ten_su",
23: "ten_kai",
24: "aiten",
25: "ten_card",
26: "ten_delete",
27: "ten_post",
28: "ten_get",
29: "ten_at",
30: "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 [4]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 "did":
if err := func() error {
s.Did.Reset()
if err := s.Did.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"did\"")
}
case "member":
if err := func() error {
s.Member.Reset()
if err := s.Member.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"member\"")
}
case "book":
if err := func() error {
s.Book.Reset()
if err := s.Book.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"book\"")
}
case "manga":
if err := func() error {
s.Manga.Reset()
if err := s.Manga.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"manga\"")
}
case "badge":
if err := func() error {
s.Badge.Reset()
if err := s.Badge.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"badge\"")
}
case "bsky":
if err := func() error {
s.Bsky.Reset()
if err := s.Bsky.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"bsky\"")
}
case "mastodon":
if err := func() error {
s.Mastodon.Reset()
if err := s.Mastodon.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"mastodon\"")
}
case "delete":
if err := func() error {
s.Delete.Reset()
if err := s.Delete.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"delete\"")
}
case "handle":
if err := func() error {
s.Handle.Reset()
if err := s.Handle.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"handle\"")
}
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 "raid_at":
if err := func() error {
s.RaidAt.Reset()
if err := s.RaidAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"raid_at\"")
}
case "egg_at":
if err := func() error {
s.EggAt.Reset()
if err := s.EggAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"egg_at\"")
}
case "luck":
if err := func() error {
s.Luck.Reset()
if err := s.Luck.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"luck\"")
}
case "luck_at":
if err := func() error {
s.LuckAt.Reset()
if err := s.LuckAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"luck_at\"")
}
case "like":
if err := func() error {
s.Like.Reset()
if err := s.Like.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"like\"")
}
case "like_rank":
if err := func() error {
s.LikeRank.Reset()
if err := s.LikeRank.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"like_rank\"")
}
case "like_at":
if err := func() error {
s.LikeAt.Reset()
if err := s.LikeAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"like_at\"")
}
case "fav":
if err := func() error {
s.Fav.Reset()
if err := s.Fav.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"fav\"")
}
case "ten":
if err := func() error {
s.Ten.Reset()
if err := s.Ten.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten\"")
}
case "ten_su":
if err := func() error {
s.TenSu.Reset()
if err := s.TenSu.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_su\"")
}
case "ten_kai":
if err := func() error {
s.TenKai.Reset()
if err := s.TenKai.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_kai\"")
}
case "aiten":
if err := func() error {
s.Aiten.Reset()
if err := s.Aiten.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"aiten\"")
}
case "ten_card":
if err := func() error {
s.TenCard.Reset()
if err := s.TenCard.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_card\"")
}
case "ten_delete":
if err := func() error {
s.TenDelete.Reset()
if err := s.TenDelete.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_delete\"")
}
case "ten_post":
if err := func() error {
s.TenPost.Reset()
if err := s.TenPost.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_post\"")
}
case "ten_get":
if err := func() error {
s.TenGet.Reset()
if err := s.TenGet.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_get\"")
}
case "ten_at":
if err := func() error {
s.TenAt.Reset()
if err := s.TenAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_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 [4]uint8{
0b00000011,
0b00000000,
0b00000000,
0b00000000,
} {
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.Did.Set {
e.FieldStart("did")
s.Did.Encode(e)
}
}
{
if s.Member.Set {
e.FieldStart("member")
s.Member.Encode(e)
}
}
{
if s.Book.Set {
e.FieldStart("book")
s.Book.Encode(e)
}
}
{
if s.Manga.Set {
e.FieldStart("manga")
s.Manga.Encode(e)
}
}
{
if s.Badge.Set {
e.FieldStart("badge")
s.Badge.Encode(e)
}
}
{
if s.Bsky.Set {
e.FieldStart("bsky")
s.Bsky.Encode(e)
}
}
{
if s.Mastodon.Set {
e.FieldStart("mastodon")
s.Mastodon.Encode(e)
}
}
{
if s.Delete.Set {
e.FieldStart("delete")
s.Delete.Encode(e)
}
}
{
if s.Handle.Set {
e.FieldStart("handle")
s.Handle.Encode(e)
}
}
{
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.RaidAt.Set {
e.FieldStart("raid_at")
s.RaidAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.EggAt.Set {
e.FieldStart("egg_at")
s.EggAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.Luck.Set {
e.FieldStart("luck")
s.Luck.Encode(e)
}
}
{
if s.LuckAt.Set {
e.FieldStart("luck_at")
s.LuckAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.Like.Set {
e.FieldStart("like")
s.Like.Encode(e)
}
}
{
if s.LikeRank.Set {
e.FieldStart("like_rank")
s.LikeRank.Encode(e)
}
}
{
if s.LikeAt.Set {
e.FieldStart("like_at")
s.LikeAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.Fav.Set {
e.FieldStart("fav")
s.Fav.Encode(e)
}
}
{
if s.Ten.Set {
e.FieldStart("ten")
s.Ten.Encode(e)
}
}
{
if s.TenSu.Set {
e.FieldStart("ten_su")
s.TenSu.Encode(e)
}
}
{
if s.TenKai.Set {
e.FieldStart("ten_kai")
s.TenKai.Encode(e)
}
}
{
if s.Aiten.Set {
e.FieldStart("aiten")
s.Aiten.Encode(e)
}
}
{
if s.TenCard.Set {
e.FieldStart("ten_card")
s.TenCard.Encode(e)
}
}
{
if s.TenDelete.Set {
e.FieldStart("ten_delete")
s.TenDelete.Encode(e)
}
}
{
if s.TenPost.Set {
e.FieldStart("ten_post")
s.TenPost.Encode(e)
}
}
{
if s.TenGet.Set {
e.FieldStart("ten_get")
s.TenGet.Encode(e)
}
}
{
if s.TenAt.Set {
e.FieldStart("ten_at")
s.TenAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.Next.Set {
e.FieldStart("next")
s.Next.Encode(e)
}
}
}
var jsonFieldsNameOfUserList = [31]string{
0: "id",
1: "username",
2: "did",
3: "member",
4: "book",
5: "manga",
6: "badge",
7: "bsky",
8: "mastodon",
9: "delete",
10: "handle",
11: "created_at",
12: "updated_at",
13: "raid_at",
14: "egg_at",
15: "luck",
16: "luck_at",
17: "like",
18: "like_rank",
19: "like_at",
20: "fav",
21: "ten",
22: "ten_su",
23: "ten_kai",
24: "aiten",
25: "ten_card",
26: "ten_delete",
27: "ten_post",
28: "ten_get",
29: "ten_at",
30: "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 [4]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 "did":
if err := func() error {
s.Did.Reset()
if err := s.Did.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"did\"")
}
case "member":
if err := func() error {
s.Member.Reset()
if err := s.Member.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"member\"")
}
case "book":
if err := func() error {
s.Book.Reset()
if err := s.Book.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"book\"")
}
case "manga":
if err := func() error {
s.Manga.Reset()
if err := s.Manga.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"manga\"")
}
case "badge":
if err := func() error {
s.Badge.Reset()
if err := s.Badge.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"badge\"")
}
case "bsky":
if err := func() error {
s.Bsky.Reset()
if err := s.Bsky.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"bsky\"")
}
case "mastodon":
if err := func() error {
s.Mastodon.Reset()
if err := s.Mastodon.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"mastodon\"")
}
case "delete":
if err := func() error {
s.Delete.Reset()
if err := s.Delete.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"delete\"")
}
case "handle":
if err := func() error {
s.Handle.Reset()
if err := s.Handle.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"handle\"")
}
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 "raid_at":
if err := func() error {
s.RaidAt.Reset()
if err := s.RaidAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"raid_at\"")
}
case "egg_at":
if err := func() error {
s.EggAt.Reset()
if err := s.EggAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"egg_at\"")
}
case "luck":
if err := func() error {
s.Luck.Reset()
if err := s.Luck.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"luck\"")
}
case "luck_at":
if err := func() error {
s.LuckAt.Reset()
if err := s.LuckAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"luck_at\"")
}
case "like":
if err := func() error {
s.Like.Reset()
if err := s.Like.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"like\"")
}
case "like_rank":
if err := func() error {
s.LikeRank.Reset()
if err := s.LikeRank.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"like_rank\"")
}
case "like_at":
if err := func() error {
s.LikeAt.Reset()
if err := s.LikeAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"like_at\"")
}
case "fav":
if err := func() error {
s.Fav.Reset()
if err := s.Fav.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"fav\"")
}
case "ten":
if err := func() error {
s.Ten.Reset()
if err := s.Ten.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten\"")
}
case "ten_su":
if err := func() error {
s.TenSu.Reset()
if err := s.TenSu.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_su\"")
}
case "ten_kai":
if err := func() error {
s.TenKai.Reset()
if err := s.TenKai.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_kai\"")
}
case "aiten":
if err := func() error {
s.Aiten.Reset()
if err := s.Aiten.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"aiten\"")
}
case "ten_card":
if err := func() error {
s.TenCard.Reset()
if err := s.TenCard.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_card\"")
}
case "ten_delete":
if err := func() error {
s.TenDelete.Reset()
if err := s.TenDelete.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_delete\"")
}
case "ten_post":
if err := func() error {
s.TenPost.Reset()
if err := s.TenPost.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_post\"")
}
case "ten_get":
if err := func() error {
s.TenGet.Reset()
if err := s.TenGet.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_get\"")
}
case "ten_at":
if err := func() error {
s.TenAt.Reset()
if err := s.TenAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_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 [4]uint8{
0b00000011,
0b00000000,
0b00000000,
0b00000000,
} {
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.Did.Set {
e.FieldStart("did")
s.Did.Encode(e)
}
}
{
if s.Member.Set {
e.FieldStart("member")
s.Member.Encode(e)
}
}
{
if s.Book.Set {
e.FieldStart("book")
s.Book.Encode(e)
}
}
{
if s.Manga.Set {
e.FieldStart("manga")
s.Manga.Encode(e)
}
}
{
if s.Badge.Set {
e.FieldStart("badge")
s.Badge.Encode(e)
}
}
{
if s.Bsky.Set {
e.FieldStart("bsky")
s.Bsky.Encode(e)
}
}
{
if s.Mastodon.Set {
e.FieldStart("mastodon")
s.Mastodon.Encode(e)
}
}
{
if s.Delete.Set {
e.FieldStart("delete")
s.Delete.Encode(e)
}
}
{
if s.Handle.Set {
e.FieldStart("handle")
s.Handle.Encode(e)
}
}
{
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.RaidAt.Set {
e.FieldStart("raid_at")
s.RaidAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.EggAt.Set {
e.FieldStart("egg_at")
s.EggAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.Luck.Set {
e.FieldStart("luck")
s.Luck.Encode(e)
}
}
{
if s.LuckAt.Set {
e.FieldStart("luck_at")
s.LuckAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.Like.Set {
e.FieldStart("like")
s.Like.Encode(e)
}
}
{
if s.LikeRank.Set {
e.FieldStart("like_rank")
s.LikeRank.Encode(e)
}
}
{
if s.LikeAt.Set {
e.FieldStart("like_at")
s.LikeAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.Fav.Set {
e.FieldStart("fav")
s.Fav.Encode(e)
}
}
{
if s.Ten.Set {
e.FieldStart("ten")
s.Ten.Encode(e)
}
}
{
if s.TenSu.Set {
e.FieldStart("ten_su")
s.TenSu.Encode(e)
}
}
{
if s.TenKai.Set {
e.FieldStart("ten_kai")
s.TenKai.Encode(e)
}
}
{
if s.Aiten.Set {
e.FieldStart("aiten")
s.Aiten.Encode(e)
}
}
{
if s.TenCard.Set {
e.FieldStart("ten_card")
s.TenCard.Encode(e)
}
}
{
if s.TenDelete.Set {
e.FieldStart("ten_delete")
s.TenDelete.Encode(e)
}
}
{
if s.TenPost.Set {
e.FieldStart("ten_post")
s.TenPost.Encode(e)
}
}
{
if s.TenGet.Set {
e.FieldStart("ten_get")
s.TenGet.Encode(e)
}
}
{
if s.TenAt.Set {
e.FieldStart("ten_at")
s.TenAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.Next.Set {
e.FieldStart("next")
s.Next.Encode(e)
}
}
}
var jsonFieldsNameOfUserRead = [31]string{
0: "id",
1: "username",
2: "did",
3: "member",
4: "book",
5: "manga",
6: "badge",
7: "bsky",
8: "mastodon",
9: "delete",
10: "handle",
11: "created_at",
12: "updated_at",
13: "raid_at",
14: "egg_at",
15: "luck",
16: "luck_at",
17: "like",
18: "like_rank",
19: "like_at",
20: "fav",
21: "ten",
22: "ten_su",
23: "ten_kai",
24: "aiten",
25: "ten_card",
26: "ten_delete",
27: "ten_post",
28: "ten_get",
29: "ten_at",
30: "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 [4]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 "did":
if err := func() error {
s.Did.Reset()
if err := s.Did.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"did\"")
}
case "member":
if err := func() error {
s.Member.Reset()
if err := s.Member.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"member\"")
}
case "book":
if err := func() error {
s.Book.Reset()
if err := s.Book.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"book\"")
}
case "manga":
if err := func() error {
s.Manga.Reset()
if err := s.Manga.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"manga\"")
}
case "badge":
if err := func() error {
s.Badge.Reset()
if err := s.Badge.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"badge\"")
}
case "bsky":
if err := func() error {
s.Bsky.Reset()
if err := s.Bsky.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"bsky\"")
}
case "mastodon":
if err := func() error {
s.Mastodon.Reset()
if err := s.Mastodon.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"mastodon\"")
}
case "delete":
if err := func() error {
s.Delete.Reset()
if err := s.Delete.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"delete\"")
}
case "handle":
if err := func() error {
s.Handle.Reset()
if err := s.Handle.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"handle\"")
}
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 "raid_at":
if err := func() error {
s.RaidAt.Reset()
if err := s.RaidAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"raid_at\"")
}
case "egg_at":
if err := func() error {
s.EggAt.Reset()
if err := s.EggAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"egg_at\"")
}
case "luck":
if err := func() error {
s.Luck.Reset()
if err := s.Luck.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"luck\"")
}
case "luck_at":
if err := func() error {
s.LuckAt.Reset()
if err := s.LuckAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"luck_at\"")
}
case "like":
if err := func() error {
s.Like.Reset()
if err := s.Like.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"like\"")
}
case "like_rank":
if err := func() error {
s.LikeRank.Reset()
if err := s.LikeRank.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"like_rank\"")
}
case "like_at":
if err := func() error {
s.LikeAt.Reset()
if err := s.LikeAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"like_at\"")
}
case "fav":
if err := func() error {
s.Fav.Reset()
if err := s.Fav.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"fav\"")
}
case "ten":
if err := func() error {
s.Ten.Reset()
if err := s.Ten.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten\"")
}
case "ten_su":
if err := func() error {
s.TenSu.Reset()
if err := s.TenSu.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_su\"")
}
case "ten_kai":
if err := func() error {
s.TenKai.Reset()
if err := s.TenKai.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_kai\"")
}
case "aiten":
if err := func() error {
s.Aiten.Reset()
if err := s.Aiten.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"aiten\"")
}
case "ten_card":
if err := func() error {
s.TenCard.Reset()
if err := s.TenCard.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_card\"")
}
case "ten_delete":
if err := func() error {
s.TenDelete.Reset()
if err := s.TenDelete.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_delete\"")
}
case "ten_post":
if err := func() error {
s.TenPost.Reset()
if err := s.TenPost.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_post\"")
}
case "ten_get":
if err := func() error {
s.TenGet.Reset()
if err := s.TenGet.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_get\"")
}
case "ten_at":
if err := func() error {
s.TenAt.Reset()
if err := s.TenAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_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 [4]uint8{
0b00000011,
0b00000000,
0b00000000,
0b00000000,
} {
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.Did.Set {
e.FieldStart("did")
s.Did.Encode(e)
}
}
{
if s.Member.Set {
e.FieldStart("member")
s.Member.Encode(e)
}
}
{
if s.Book.Set {
e.FieldStart("book")
s.Book.Encode(e)
}
}
{
if s.Manga.Set {
e.FieldStart("manga")
s.Manga.Encode(e)
}
}
{
if s.Badge.Set {
e.FieldStart("badge")
s.Badge.Encode(e)
}
}
{
if s.Bsky.Set {
e.FieldStart("bsky")
s.Bsky.Encode(e)
}
}
{
if s.Mastodon.Set {
e.FieldStart("mastodon")
s.Mastodon.Encode(e)
}
}
{
if s.Delete.Set {
e.FieldStart("delete")
s.Delete.Encode(e)
}
}
{
if s.Handle.Set {
e.FieldStart("handle")
s.Handle.Encode(e)
}
}
{
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.RaidAt.Set {
e.FieldStart("raid_at")
s.RaidAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.EggAt.Set {
e.FieldStart("egg_at")
s.EggAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.Luck.Set {
e.FieldStart("luck")
s.Luck.Encode(e)
}
}
{
if s.LuckAt.Set {
e.FieldStart("luck_at")
s.LuckAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.Like.Set {
e.FieldStart("like")
s.Like.Encode(e)
}
}
{
if s.LikeRank.Set {
e.FieldStart("like_rank")
s.LikeRank.Encode(e)
}
}
{
if s.LikeAt.Set {
e.FieldStart("like_at")
s.LikeAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.Fav.Set {
e.FieldStart("fav")
s.Fav.Encode(e)
}
}
{
if s.Ten.Set {
e.FieldStart("ten")
s.Ten.Encode(e)
}
}
{
if s.TenSu.Set {
e.FieldStart("ten_su")
s.TenSu.Encode(e)
}
}
{
if s.TenKai.Set {
e.FieldStart("ten_kai")
s.TenKai.Encode(e)
}
}
{
if s.Aiten.Set {
e.FieldStart("aiten")
s.Aiten.Encode(e)
}
}
{
if s.TenCard.Set {
e.FieldStart("ten_card")
s.TenCard.Encode(e)
}
}
{
if s.TenDelete.Set {
e.FieldStart("ten_delete")
s.TenDelete.Encode(e)
}
}
{
if s.TenPost.Set {
e.FieldStart("ten_post")
s.TenPost.Encode(e)
}
}
{
if s.TenGet.Set {
e.FieldStart("ten_get")
s.TenGet.Encode(e)
}
}
{
if s.TenAt.Set {
e.FieldStart("ten_at")
s.TenAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.Next.Set {
e.FieldStart("next")
s.Next.Encode(e)
}
}
}
var jsonFieldsNameOfUserUpdate = [31]string{
0: "id",
1: "username",
2: "did",
3: "member",
4: "book",
5: "manga",
6: "badge",
7: "bsky",
8: "mastodon",
9: "delete",
10: "handle",
11: "created_at",
12: "updated_at",
13: "raid_at",
14: "egg_at",
15: "luck",
16: "luck_at",
17: "like",
18: "like_rank",
19: "like_at",
20: "fav",
21: "ten",
22: "ten_su",
23: "ten_kai",
24: "aiten",
25: "ten_card",
26: "ten_delete",
27: "ten_post",
28: "ten_get",
29: "ten_at",
30: "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 [4]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 "did":
if err := func() error {
s.Did.Reset()
if err := s.Did.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"did\"")
}
case "member":
if err := func() error {
s.Member.Reset()
if err := s.Member.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"member\"")
}
case "book":
if err := func() error {
s.Book.Reset()
if err := s.Book.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"book\"")
}
case "manga":
if err := func() error {
s.Manga.Reset()
if err := s.Manga.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"manga\"")
}
case "badge":
if err := func() error {
s.Badge.Reset()
if err := s.Badge.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"badge\"")
}
case "bsky":
if err := func() error {
s.Bsky.Reset()
if err := s.Bsky.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"bsky\"")
}
case "mastodon":
if err := func() error {
s.Mastodon.Reset()
if err := s.Mastodon.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"mastodon\"")
}
case "delete":
if err := func() error {
s.Delete.Reset()
if err := s.Delete.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"delete\"")
}
case "handle":
if err := func() error {
s.Handle.Reset()
if err := s.Handle.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"handle\"")
}
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 "raid_at":
if err := func() error {
s.RaidAt.Reset()
if err := s.RaidAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"raid_at\"")
}
case "egg_at":
if err := func() error {
s.EggAt.Reset()
if err := s.EggAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"egg_at\"")
}
case "luck":
if err := func() error {
s.Luck.Reset()
if err := s.Luck.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"luck\"")
}
case "luck_at":
if err := func() error {
s.LuckAt.Reset()
if err := s.LuckAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"luck_at\"")
}
case "like":
if err := func() error {
s.Like.Reset()
if err := s.Like.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"like\"")
}
case "like_rank":
if err := func() error {
s.LikeRank.Reset()
if err := s.LikeRank.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"like_rank\"")
}
case "like_at":
if err := func() error {
s.LikeAt.Reset()
if err := s.LikeAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"like_at\"")
}
case "fav":
if err := func() error {
s.Fav.Reset()
if err := s.Fav.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"fav\"")
}
case "ten":
if err := func() error {
s.Ten.Reset()
if err := s.Ten.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten\"")
}
case "ten_su":
if err := func() error {
s.TenSu.Reset()
if err := s.TenSu.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_su\"")
}
case "ten_kai":
if err := func() error {
s.TenKai.Reset()
if err := s.TenKai.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_kai\"")
}
case "aiten":
if err := func() error {
s.Aiten.Reset()
if err := s.Aiten.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"aiten\"")
}
case "ten_card":
if err := func() error {
s.TenCard.Reset()
if err := s.TenCard.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_card\"")
}
case "ten_delete":
if err := func() error {
s.TenDelete.Reset()
if err := s.TenDelete.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_delete\"")
}
case "ten_post":
if err := func() error {
s.TenPost.Reset()
if err := s.TenPost.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_post\"")
}
case "ten_get":
if err := func() error {
s.TenGet.Reset()
if err := s.TenGet.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_get\"")
}
case "ten_at":
if err := func() error {
s.TenAt.Reset()
if err := s.TenAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ten_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 [4]uint8{
0b00000011,
0b00000000,
0b00000000,
0b00000000,
} {
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)
}
View Git Blame Copy Permalink