2886 lines
57 KiB
Go
2886 lines
57 KiB
Go
// Code generated by ogen, DO NOT EDIT.
|
|
|
|
package ogent
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"fmt"
|
|
"io"
|
|
"math"
|
|
"math/big"
|
|
"math/bits"
|
|
"net"
|
|
"net/http"
|
|
"net/url"
|
|
"regexp"
|
|
"sort"
|
|
"strconv"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/go-faster/errors"
|
|
"github.com/go-faster/jx"
|
|
"github.com/google/uuid"
|
|
"github.com/ogen-go/ogen/conv"
|
|
ht "github.com/ogen-go/ogen/http"
|
|
"github.com/ogen-go/ogen/json"
|
|
"github.com/ogen-go/ogen/otelogen"
|
|
"github.com/ogen-go/ogen/uri"
|
|
"github.com/ogen-go/ogen/validate"
|
|
"go.opentelemetry.io/otel"
|
|
"go.opentelemetry.io/otel/attribute"
|
|
"go.opentelemetry.io/otel/codes"
|
|
"go.opentelemetry.io/otel/metric"
|
|
"go.opentelemetry.io/otel/trace"
|
|
)
|
|
|
|
// No-op definition for keeping imports.
|
|
var (
|
|
_ = context.Background()
|
|
_ = fmt.Stringer(nil)
|
|
_ = strings.Builder{}
|
|
_ = errors.Is
|
|
_ = sort.Ints
|
|
_ = http.MethodGet
|
|
_ = io.Copy
|
|
_ = json.Marshal
|
|
_ = bytes.NewReader
|
|
_ = strconv.ParseInt
|
|
_ = time.Time{}
|
|
_ = conv.ToInt32
|
|
_ = uuid.UUID{}
|
|
_ = uri.PathEncoder{}
|
|
_ = url.URL{}
|
|
_ = math.Mod
|
|
_ = bits.LeadingZeros64
|
|
_ = big.Rat{}
|
|
_ = validate.Int{}
|
|
_ = ht.NewRequest
|
|
_ = net.IP{}
|
|
_ = otelogen.Version
|
|
_ = attribute.KeyValue{}
|
|
_ = trace.TraceIDFromHex
|
|
_ = otel.GetTracerProvider
|
|
_ = metric.NewNoopMeterProvider
|
|
_ = regexp.MustCompile
|
|
_ = jx.Null
|
|
_ = sync.Pool{}
|
|
_ = codes.Unset
|
|
)
|
|
|
|
// Encode implements json.Marshaler.
|
|
func (s CreateUsersReq) Encode(e *jx.Encoder) {
|
|
e.ObjStart()
|
|
s.encodeFields(e)
|
|
e.ObjEnd()
|
|
}
|
|
|
|
// encodeFields implements json.Marshaler.
|
|
func (s CreateUsersReq) encodeFields(e *jx.Encoder) {
|
|
{
|
|
|
|
e.FieldStart("user")
|
|
e.Str(s.User)
|
|
}
|
|
{
|
|
if s.Chara.Set {
|
|
e.FieldStart("chara")
|
|
s.Chara.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Skill.Set {
|
|
e.FieldStart("skill")
|
|
s.Skill.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Hp.Set {
|
|
e.FieldStart("hp")
|
|
s.Hp.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Attack.Set {
|
|
e.FieldStart("attack")
|
|
s.Attack.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Defense.Set {
|
|
e.FieldStart("defense")
|
|
s.Defense.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Critical.Set {
|
|
e.FieldStart("critical")
|
|
s.Critical.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Battle.Set {
|
|
e.FieldStart("battle")
|
|
s.Battle.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Win.Set {
|
|
e.FieldStart("win")
|
|
s.Win.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Day.Set {
|
|
e.FieldStart("day")
|
|
s.Day.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Percentage.Set {
|
|
e.FieldStart("percentage")
|
|
s.Percentage.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Limit.Set {
|
|
e.FieldStart("limit")
|
|
s.Limit.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Status.Set {
|
|
e.FieldStart("status")
|
|
s.Status.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Comment.Set {
|
|
e.FieldStart("comment")
|
|
s.Comment.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.CreatedAt.Set {
|
|
e.FieldStart("created_at")
|
|
s.CreatedAt.Encode(e, json.EncodeDateTime)
|
|
}
|
|
}
|
|
{
|
|
if s.Next.Set {
|
|
e.FieldStart("next")
|
|
s.Next.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.UpdatedAt.Set {
|
|
e.FieldStart("updated_at")
|
|
s.UpdatedAt.Encode(e, json.EncodeDateTime)
|
|
}
|
|
}
|
|
{
|
|
if s.URL.Set {
|
|
e.FieldStart("url")
|
|
s.URL.Encode(e)
|
|
}
|
|
}
|
|
}
|
|
|
|
var jsonFieldsNameOfCreateUsersReq = [18]string{
|
|
0: "user",
|
|
1: "chara",
|
|
2: "skill",
|
|
3: "hp",
|
|
4: "attack",
|
|
5: "defense",
|
|
6: "critical",
|
|
7: "battle",
|
|
8: "win",
|
|
9: "day",
|
|
10: "percentage",
|
|
11: "limit",
|
|
12: "status",
|
|
13: "comment",
|
|
14: "created_at",
|
|
15: "next",
|
|
16: "updated_at",
|
|
17: "url",
|
|
}
|
|
|
|
// Decode decodes CreateUsersReq from json.
|
|
func (s *CreateUsersReq) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode CreateUsersReq to nil")
|
|
}
|
|
var requiredBitSet [3]uint8
|
|
|
|
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
|
|
switch string(k) {
|
|
case "user":
|
|
requiredBitSet[0] |= 1 << 0
|
|
if err := func() error {
|
|
v, err := d.Str()
|
|
s.User = string(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"user\"")
|
|
}
|
|
case "chara":
|
|
if err := func() error {
|
|
s.Chara.Reset()
|
|
if err := s.Chara.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"chara\"")
|
|
}
|
|
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 "hp":
|
|
if err := func() error {
|
|
s.Hp.Reset()
|
|
if err := s.Hp.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"hp\"")
|
|
}
|
|
case "attack":
|
|
if err := func() error {
|
|
s.Attack.Reset()
|
|
if err := s.Attack.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"attack\"")
|
|
}
|
|
case "defense":
|
|
if err := func() error {
|
|
s.Defense.Reset()
|
|
if err := s.Defense.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"defense\"")
|
|
}
|
|
case "critical":
|
|
if err := func() error {
|
|
s.Critical.Reset()
|
|
if err := s.Critical.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"critical\"")
|
|
}
|
|
case "battle":
|
|
if err := func() error {
|
|
s.Battle.Reset()
|
|
if err := s.Battle.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"battle\"")
|
|
}
|
|
case "win":
|
|
if err := func() error {
|
|
s.Win.Reset()
|
|
if err := s.Win.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"win\"")
|
|
}
|
|
case "day":
|
|
if err := func() error {
|
|
s.Day.Reset()
|
|
if err := s.Day.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"day\"")
|
|
}
|
|
case "percentage":
|
|
if err := func() error {
|
|
s.Percentage.Reset()
|
|
if err := s.Percentage.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"percentage\"")
|
|
}
|
|
case "limit":
|
|
if err := func() error {
|
|
s.Limit.Reset()
|
|
if err := s.Limit.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"limit\"")
|
|
}
|
|
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 "comment":
|
|
if err := func() error {
|
|
s.Comment.Reset()
|
|
if err := s.Comment.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"comment\"")
|
|
}
|
|
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 "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 "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 "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\"")
|
|
}
|
|
default:
|
|
return d.Skip()
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
return errors.Wrap(err, "decode CreateUsersReq")
|
|
}
|
|
// Validate required fields.
|
|
var failures []validate.FieldError
|
|
for i, mask := range [3]uint8{
|
|
0b00000001,
|
|
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(jsonFieldsNameOfCreateUsersReq) {
|
|
name = jsonFieldsNameOfCreateUsersReq[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
|
|
}
|
|
|
|
// Encode encodes ListUsersOKApplicationJSON as json.
|
|
func (s ListUsersOKApplicationJSON) Encode(e *jx.Encoder) {
|
|
unwrapped := []UsersList(s)
|
|
e.ArrStart()
|
|
for _, elem := range unwrapped {
|
|
elem.Encode(e)
|
|
}
|
|
e.ArrEnd()
|
|
}
|
|
|
|
// Decode decodes ListUsersOKApplicationJSON from json.
|
|
func (s *ListUsersOKApplicationJSON) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode ListUsersOKApplicationJSON to nil")
|
|
}
|
|
var unwrapped []UsersList
|
|
if err := func() error {
|
|
unwrapped = make([]UsersList, 0)
|
|
if err := d.Arr(func(d *jx.Decoder) error {
|
|
var elem UsersList
|
|
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 = ListUsersOKApplicationJSON(unwrapped)
|
|
return nil
|
|
}
|
|
|
|
// 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
|
|
}
|
|
|
|
// 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
|
|
}
|
|
|
|
// Encode encodes float64 as json.
|
|
func (o OptFloat64) Encode(e *jx.Encoder) {
|
|
if !o.Set {
|
|
return
|
|
}
|
|
e.Float64(float64(o.Value))
|
|
}
|
|
|
|
// Decode decodes float64 from json.
|
|
func (o *OptFloat64) Decode(d *jx.Decoder) error {
|
|
if o == nil {
|
|
return errors.New("invalid: unable to decode OptFloat64 to nil")
|
|
}
|
|
o.Set = true
|
|
v, err := d.Float64()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
o.Value = float64(v)
|
|
return nil
|
|
}
|
|
|
|
// 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
|
|
}
|
|
|
|
// 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
|
|
}
|
|
|
|
// Encode implements json.Marshaler.
|
|
func (s R400) Encode(e *jx.Encoder) {
|
|
e.ObjStart()
|
|
s.encodeFields(e)
|
|
e.ObjEnd()
|
|
}
|
|
|
|
// encodeFields implements json.Marshaler.
|
|
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
|
|
}
|
|
|
|
// Encode implements json.Marshaler.
|
|
func (s R404) Encode(e *jx.Encoder) {
|
|
e.ObjStart()
|
|
s.encodeFields(e)
|
|
e.ObjEnd()
|
|
}
|
|
|
|
// encodeFields implements json.Marshaler.
|
|
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
|
|
}
|
|
|
|
// Encode implements json.Marshaler.
|
|
func (s R409) Encode(e *jx.Encoder) {
|
|
e.ObjStart()
|
|
s.encodeFields(e)
|
|
e.ObjEnd()
|
|
}
|
|
|
|
// encodeFields implements json.Marshaler.
|
|
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
|
|
}
|
|
|
|
// Encode implements json.Marshaler.
|
|
func (s R500) Encode(e *jx.Encoder) {
|
|
e.ObjStart()
|
|
s.encodeFields(e)
|
|
e.ObjEnd()
|
|
}
|
|
|
|
// encodeFields implements json.Marshaler.
|
|
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
|
|
}
|
|
|
|
// Encode implements json.Marshaler.
|
|
func (s UpdateUsersReq) Encode(e *jx.Encoder) {
|
|
e.ObjStart()
|
|
s.encodeFields(e)
|
|
e.ObjEnd()
|
|
}
|
|
|
|
// encodeFields implements json.Marshaler.
|
|
func (s UpdateUsersReq) encodeFields(e *jx.Encoder) {
|
|
{
|
|
if s.Hp.Set {
|
|
e.FieldStart("hp")
|
|
s.Hp.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Attack.Set {
|
|
e.FieldStart("attack")
|
|
s.Attack.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Defense.Set {
|
|
e.FieldStart("defense")
|
|
s.Defense.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Critical.Set {
|
|
e.FieldStart("critical")
|
|
s.Critical.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Battle.Set {
|
|
e.FieldStart("battle")
|
|
s.Battle.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Win.Set {
|
|
e.FieldStart("win")
|
|
s.Win.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Day.Set {
|
|
e.FieldStart("day")
|
|
s.Day.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Percentage.Set {
|
|
e.FieldStart("percentage")
|
|
s.Percentage.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Limit.Set {
|
|
e.FieldStart("limit")
|
|
s.Limit.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Comment.Set {
|
|
e.FieldStart("comment")
|
|
s.Comment.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Next.Set {
|
|
e.FieldStart("next")
|
|
s.Next.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.UpdatedAt.Set {
|
|
e.FieldStart("updated_at")
|
|
s.UpdatedAt.Encode(e, json.EncodeDateTime)
|
|
}
|
|
}
|
|
}
|
|
|
|
var jsonFieldsNameOfUpdateUsersReq = [12]string{
|
|
0: "hp",
|
|
1: "attack",
|
|
2: "defense",
|
|
3: "critical",
|
|
4: "battle",
|
|
5: "win",
|
|
6: "day",
|
|
7: "percentage",
|
|
8: "limit",
|
|
9: "comment",
|
|
10: "next",
|
|
11: "updated_at",
|
|
}
|
|
|
|
// Decode decodes UpdateUsersReq from json.
|
|
func (s *UpdateUsersReq) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode UpdateUsersReq to nil")
|
|
}
|
|
|
|
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
|
|
switch string(k) {
|
|
case "hp":
|
|
if err := func() error {
|
|
s.Hp.Reset()
|
|
if err := s.Hp.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"hp\"")
|
|
}
|
|
case "attack":
|
|
if err := func() error {
|
|
s.Attack.Reset()
|
|
if err := s.Attack.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"attack\"")
|
|
}
|
|
case "defense":
|
|
if err := func() error {
|
|
s.Defense.Reset()
|
|
if err := s.Defense.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"defense\"")
|
|
}
|
|
case "critical":
|
|
if err := func() error {
|
|
s.Critical.Reset()
|
|
if err := s.Critical.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"critical\"")
|
|
}
|
|
case "battle":
|
|
if err := func() error {
|
|
s.Battle.Reset()
|
|
if err := s.Battle.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"battle\"")
|
|
}
|
|
case "win":
|
|
if err := func() error {
|
|
s.Win.Reset()
|
|
if err := s.Win.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"win\"")
|
|
}
|
|
case "day":
|
|
if err := func() error {
|
|
s.Day.Reset()
|
|
if err := s.Day.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"day\"")
|
|
}
|
|
case "percentage":
|
|
if err := func() error {
|
|
s.Percentage.Reset()
|
|
if err := s.Percentage.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"percentage\"")
|
|
}
|
|
case "limit":
|
|
if err := func() error {
|
|
s.Limit.Reset()
|
|
if err := s.Limit.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"limit\"")
|
|
}
|
|
case "comment":
|
|
if err := func() error {
|
|
s.Comment.Reset()
|
|
if err := s.Comment.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"comment\"")
|
|
}
|
|
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 "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\"")
|
|
}
|
|
default:
|
|
return d.Skip()
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
return errors.Wrap(err, "decode UpdateUsersReq")
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// Encode implements json.Marshaler.
|
|
func (s UsersCreate) Encode(e *jx.Encoder) {
|
|
e.ObjStart()
|
|
s.encodeFields(e)
|
|
e.ObjEnd()
|
|
}
|
|
|
|
// encodeFields implements json.Marshaler.
|
|
func (s UsersCreate) encodeFields(e *jx.Encoder) {
|
|
{
|
|
|
|
e.FieldStart("id")
|
|
e.Int(s.ID)
|
|
}
|
|
{
|
|
|
|
e.FieldStart("user")
|
|
e.Str(s.User)
|
|
}
|
|
{
|
|
if s.Chara.Set {
|
|
e.FieldStart("chara")
|
|
s.Chara.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Skill.Set {
|
|
e.FieldStart("skill")
|
|
s.Skill.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Hp.Set {
|
|
e.FieldStart("hp")
|
|
s.Hp.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Attack.Set {
|
|
e.FieldStart("attack")
|
|
s.Attack.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Defense.Set {
|
|
e.FieldStart("defense")
|
|
s.Defense.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Critical.Set {
|
|
e.FieldStart("critical")
|
|
s.Critical.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Battle.Set {
|
|
e.FieldStart("battle")
|
|
s.Battle.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Win.Set {
|
|
e.FieldStart("win")
|
|
s.Win.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Day.Set {
|
|
e.FieldStart("day")
|
|
s.Day.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Percentage.Set {
|
|
e.FieldStart("percentage")
|
|
s.Percentage.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Limit.Set {
|
|
e.FieldStart("limit")
|
|
s.Limit.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Status.Set {
|
|
e.FieldStart("status")
|
|
s.Status.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Comment.Set {
|
|
e.FieldStart("comment")
|
|
s.Comment.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.CreatedAt.Set {
|
|
e.FieldStart("created_at")
|
|
s.CreatedAt.Encode(e, json.EncodeDateTime)
|
|
}
|
|
}
|
|
{
|
|
if s.Next.Set {
|
|
e.FieldStart("next")
|
|
s.Next.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.UpdatedAt.Set {
|
|
e.FieldStart("updated_at")
|
|
s.UpdatedAt.Encode(e, json.EncodeDateTime)
|
|
}
|
|
}
|
|
{
|
|
if s.URL.Set {
|
|
e.FieldStart("url")
|
|
s.URL.Encode(e)
|
|
}
|
|
}
|
|
}
|
|
|
|
var jsonFieldsNameOfUsersCreate = [19]string{
|
|
0: "id",
|
|
1: "user",
|
|
2: "chara",
|
|
3: "skill",
|
|
4: "hp",
|
|
5: "attack",
|
|
6: "defense",
|
|
7: "critical",
|
|
8: "battle",
|
|
9: "win",
|
|
10: "day",
|
|
11: "percentage",
|
|
12: "limit",
|
|
13: "status",
|
|
14: "comment",
|
|
15: "created_at",
|
|
16: "next",
|
|
17: "updated_at",
|
|
18: "url",
|
|
}
|
|
|
|
// Decode decodes UsersCreate from json.
|
|
func (s *UsersCreate) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode UsersCreate to nil")
|
|
}
|
|
var requiredBitSet [3]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 "user":
|
|
requiredBitSet[0] |= 1 << 1
|
|
if err := func() error {
|
|
v, err := d.Str()
|
|
s.User = string(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"user\"")
|
|
}
|
|
case "chara":
|
|
if err := func() error {
|
|
s.Chara.Reset()
|
|
if err := s.Chara.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"chara\"")
|
|
}
|
|
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 "hp":
|
|
if err := func() error {
|
|
s.Hp.Reset()
|
|
if err := s.Hp.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"hp\"")
|
|
}
|
|
case "attack":
|
|
if err := func() error {
|
|
s.Attack.Reset()
|
|
if err := s.Attack.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"attack\"")
|
|
}
|
|
case "defense":
|
|
if err := func() error {
|
|
s.Defense.Reset()
|
|
if err := s.Defense.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"defense\"")
|
|
}
|
|
case "critical":
|
|
if err := func() error {
|
|
s.Critical.Reset()
|
|
if err := s.Critical.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"critical\"")
|
|
}
|
|
case "battle":
|
|
if err := func() error {
|
|
s.Battle.Reset()
|
|
if err := s.Battle.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"battle\"")
|
|
}
|
|
case "win":
|
|
if err := func() error {
|
|
s.Win.Reset()
|
|
if err := s.Win.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"win\"")
|
|
}
|
|
case "day":
|
|
if err := func() error {
|
|
s.Day.Reset()
|
|
if err := s.Day.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"day\"")
|
|
}
|
|
case "percentage":
|
|
if err := func() error {
|
|
s.Percentage.Reset()
|
|
if err := s.Percentage.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"percentage\"")
|
|
}
|
|
case "limit":
|
|
if err := func() error {
|
|
s.Limit.Reset()
|
|
if err := s.Limit.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"limit\"")
|
|
}
|
|
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 "comment":
|
|
if err := func() error {
|
|
s.Comment.Reset()
|
|
if err := s.Comment.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"comment\"")
|
|
}
|
|
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 "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 "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 "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\"")
|
|
}
|
|
default:
|
|
return d.Skip()
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
return errors.Wrap(err, "decode UsersCreate")
|
|
}
|
|
// Validate required fields.
|
|
var failures []validate.FieldError
|
|
for i, mask := range [3]uint8{
|
|
0b00000011,
|
|
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(jsonFieldsNameOfUsersCreate) {
|
|
name = jsonFieldsNameOfUsersCreate[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
|
|
}
|
|
|
|
// Encode implements json.Marshaler.
|
|
func (s UsersList) Encode(e *jx.Encoder) {
|
|
e.ObjStart()
|
|
s.encodeFields(e)
|
|
e.ObjEnd()
|
|
}
|
|
|
|
// encodeFields implements json.Marshaler.
|
|
func (s UsersList) encodeFields(e *jx.Encoder) {
|
|
{
|
|
|
|
e.FieldStart("id")
|
|
e.Int(s.ID)
|
|
}
|
|
{
|
|
|
|
e.FieldStart("user")
|
|
e.Str(s.User)
|
|
}
|
|
{
|
|
if s.Chara.Set {
|
|
e.FieldStart("chara")
|
|
s.Chara.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Skill.Set {
|
|
e.FieldStart("skill")
|
|
s.Skill.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Hp.Set {
|
|
e.FieldStart("hp")
|
|
s.Hp.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Attack.Set {
|
|
e.FieldStart("attack")
|
|
s.Attack.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Defense.Set {
|
|
e.FieldStart("defense")
|
|
s.Defense.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Critical.Set {
|
|
e.FieldStart("critical")
|
|
s.Critical.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Battle.Set {
|
|
e.FieldStart("battle")
|
|
s.Battle.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Win.Set {
|
|
e.FieldStart("win")
|
|
s.Win.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Day.Set {
|
|
e.FieldStart("day")
|
|
s.Day.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Percentage.Set {
|
|
e.FieldStart("percentage")
|
|
s.Percentage.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Limit.Set {
|
|
e.FieldStart("limit")
|
|
s.Limit.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Status.Set {
|
|
e.FieldStart("status")
|
|
s.Status.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Comment.Set {
|
|
e.FieldStart("comment")
|
|
s.Comment.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.CreatedAt.Set {
|
|
e.FieldStart("created_at")
|
|
s.CreatedAt.Encode(e, json.EncodeDateTime)
|
|
}
|
|
}
|
|
{
|
|
if s.Next.Set {
|
|
e.FieldStart("next")
|
|
s.Next.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.UpdatedAt.Set {
|
|
e.FieldStart("updated_at")
|
|
s.UpdatedAt.Encode(e, json.EncodeDateTime)
|
|
}
|
|
}
|
|
{
|
|
if s.URL.Set {
|
|
e.FieldStart("url")
|
|
s.URL.Encode(e)
|
|
}
|
|
}
|
|
}
|
|
|
|
var jsonFieldsNameOfUsersList = [19]string{
|
|
0: "id",
|
|
1: "user",
|
|
2: "chara",
|
|
3: "skill",
|
|
4: "hp",
|
|
5: "attack",
|
|
6: "defense",
|
|
7: "critical",
|
|
8: "battle",
|
|
9: "win",
|
|
10: "day",
|
|
11: "percentage",
|
|
12: "limit",
|
|
13: "status",
|
|
14: "comment",
|
|
15: "created_at",
|
|
16: "next",
|
|
17: "updated_at",
|
|
18: "url",
|
|
}
|
|
|
|
// Decode decodes UsersList from json.
|
|
func (s *UsersList) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode UsersList to nil")
|
|
}
|
|
var requiredBitSet [3]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 "user":
|
|
requiredBitSet[0] |= 1 << 1
|
|
if err := func() error {
|
|
v, err := d.Str()
|
|
s.User = string(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"user\"")
|
|
}
|
|
case "chara":
|
|
if err := func() error {
|
|
s.Chara.Reset()
|
|
if err := s.Chara.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"chara\"")
|
|
}
|
|
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 "hp":
|
|
if err := func() error {
|
|
s.Hp.Reset()
|
|
if err := s.Hp.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"hp\"")
|
|
}
|
|
case "attack":
|
|
if err := func() error {
|
|
s.Attack.Reset()
|
|
if err := s.Attack.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"attack\"")
|
|
}
|
|
case "defense":
|
|
if err := func() error {
|
|
s.Defense.Reset()
|
|
if err := s.Defense.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"defense\"")
|
|
}
|
|
case "critical":
|
|
if err := func() error {
|
|
s.Critical.Reset()
|
|
if err := s.Critical.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"critical\"")
|
|
}
|
|
case "battle":
|
|
if err := func() error {
|
|
s.Battle.Reset()
|
|
if err := s.Battle.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"battle\"")
|
|
}
|
|
case "win":
|
|
if err := func() error {
|
|
s.Win.Reset()
|
|
if err := s.Win.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"win\"")
|
|
}
|
|
case "day":
|
|
if err := func() error {
|
|
s.Day.Reset()
|
|
if err := s.Day.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"day\"")
|
|
}
|
|
case "percentage":
|
|
if err := func() error {
|
|
s.Percentage.Reset()
|
|
if err := s.Percentage.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"percentage\"")
|
|
}
|
|
case "limit":
|
|
if err := func() error {
|
|
s.Limit.Reset()
|
|
if err := s.Limit.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"limit\"")
|
|
}
|
|
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 "comment":
|
|
if err := func() error {
|
|
s.Comment.Reset()
|
|
if err := s.Comment.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"comment\"")
|
|
}
|
|
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 "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 "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 "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\"")
|
|
}
|
|
default:
|
|
return d.Skip()
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
return errors.Wrap(err, "decode UsersList")
|
|
}
|
|
// Validate required fields.
|
|
var failures []validate.FieldError
|
|
for i, mask := range [3]uint8{
|
|
0b00000011,
|
|
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(jsonFieldsNameOfUsersList) {
|
|
name = jsonFieldsNameOfUsersList[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
|
|
}
|
|
|
|
// Encode implements json.Marshaler.
|
|
func (s UsersRead) Encode(e *jx.Encoder) {
|
|
e.ObjStart()
|
|
s.encodeFields(e)
|
|
e.ObjEnd()
|
|
}
|
|
|
|
// encodeFields implements json.Marshaler.
|
|
func (s UsersRead) encodeFields(e *jx.Encoder) {
|
|
{
|
|
|
|
e.FieldStart("id")
|
|
e.Int(s.ID)
|
|
}
|
|
{
|
|
|
|
e.FieldStart("user")
|
|
e.Str(s.User)
|
|
}
|
|
{
|
|
if s.Chara.Set {
|
|
e.FieldStart("chara")
|
|
s.Chara.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Skill.Set {
|
|
e.FieldStart("skill")
|
|
s.Skill.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Hp.Set {
|
|
e.FieldStart("hp")
|
|
s.Hp.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Attack.Set {
|
|
e.FieldStart("attack")
|
|
s.Attack.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Defense.Set {
|
|
e.FieldStart("defense")
|
|
s.Defense.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Critical.Set {
|
|
e.FieldStart("critical")
|
|
s.Critical.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Battle.Set {
|
|
e.FieldStart("battle")
|
|
s.Battle.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Win.Set {
|
|
e.FieldStart("win")
|
|
s.Win.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Day.Set {
|
|
e.FieldStart("day")
|
|
s.Day.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Percentage.Set {
|
|
e.FieldStart("percentage")
|
|
s.Percentage.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Limit.Set {
|
|
e.FieldStart("limit")
|
|
s.Limit.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Status.Set {
|
|
e.FieldStart("status")
|
|
s.Status.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Comment.Set {
|
|
e.FieldStart("comment")
|
|
s.Comment.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.CreatedAt.Set {
|
|
e.FieldStart("created_at")
|
|
s.CreatedAt.Encode(e, json.EncodeDateTime)
|
|
}
|
|
}
|
|
{
|
|
if s.Next.Set {
|
|
e.FieldStart("next")
|
|
s.Next.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.UpdatedAt.Set {
|
|
e.FieldStart("updated_at")
|
|
s.UpdatedAt.Encode(e, json.EncodeDateTime)
|
|
}
|
|
}
|
|
{
|
|
if s.URL.Set {
|
|
e.FieldStart("url")
|
|
s.URL.Encode(e)
|
|
}
|
|
}
|
|
}
|
|
|
|
var jsonFieldsNameOfUsersRead = [19]string{
|
|
0: "id",
|
|
1: "user",
|
|
2: "chara",
|
|
3: "skill",
|
|
4: "hp",
|
|
5: "attack",
|
|
6: "defense",
|
|
7: "critical",
|
|
8: "battle",
|
|
9: "win",
|
|
10: "day",
|
|
11: "percentage",
|
|
12: "limit",
|
|
13: "status",
|
|
14: "comment",
|
|
15: "created_at",
|
|
16: "next",
|
|
17: "updated_at",
|
|
18: "url",
|
|
}
|
|
|
|
// Decode decodes UsersRead from json.
|
|
func (s *UsersRead) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode UsersRead to nil")
|
|
}
|
|
var requiredBitSet [3]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 "user":
|
|
requiredBitSet[0] |= 1 << 1
|
|
if err := func() error {
|
|
v, err := d.Str()
|
|
s.User = string(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"user\"")
|
|
}
|
|
case "chara":
|
|
if err := func() error {
|
|
s.Chara.Reset()
|
|
if err := s.Chara.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"chara\"")
|
|
}
|
|
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 "hp":
|
|
if err := func() error {
|
|
s.Hp.Reset()
|
|
if err := s.Hp.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"hp\"")
|
|
}
|
|
case "attack":
|
|
if err := func() error {
|
|
s.Attack.Reset()
|
|
if err := s.Attack.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"attack\"")
|
|
}
|
|
case "defense":
|
|
if err := func() error {
|
|
s.Defense.Reset()
|
|
if err := s.Defense.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"defense\"")
|
|
}
|
|
case "critical":
|
|
if err := func() error {
|
|
s.Critical.Reset()
|
|
if err := s.Critical.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"critical\"")
|
|
}
|
|
case "battle":
|
|
if err := func() error {
|
|
s.Battle.Reset()
|
|
if err := s.Battle.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"battle\"")
|
|
}
|
|
case "win":
|
|
if err := func() error {
|
|
s.Win.Reset()
|
|
if err := s.Win.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"win\"")
|
|
}
|
|
case "day":
|
|
if err := func() error {
|
|
s.Day.Reset()
|
|
if err := s.Day.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"day\"")
|
|
}
|
|
case "percentage":
|
|
if err := func() error {
|
|
s.Percentage.Reset()
|
|
if err := s.Percentage.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"percentage\"")
|
|
}
|
|
case "limit":
|
|
if err := func() error {
|
|
s.Limit.Reset()
|
|
if err := s.Limit.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"limit\"")
|
|
}
|
|
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 "comment":
|
|
if err := func() error {
|
|
s.Comment.Reset()
|
|
if err := s.Comment.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"comment\"")
|
|
}
|
|
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 "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 "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 "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\"")
|
|
}
|
|
default:
|
|
return d.Skip()
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
return errors.Wrap(err, "decode UsersRead")
|
|
}
|
|
// Validate required fields.
|
|
var failures []validate.FieldError
|
|
for i, mask := range [3]uint8{
|
|
0b00000011,
|
|
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(jsonFieldsNameOfUsersRead) {
|
|
name = jsonFieldsNameOfUsersRead[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
|
|
}
|
|
|
|
// Encode implements json.Marshaler.
|
|
func (s UsersUpdate) Encode(e *jx.Encoder) {
|
|
e.ObjStart()
|
|
s.encodeFields(e)
|
|
e.ObjEnd()
|
|
}
|
|
|
|
// encodeFields implements json.Marshaler.
|
|
func (s UsersUpdate) encodeFields(e *jx.Encoder) {
|
|
{
|
|
|
|
e.FieldStart("id")
|
|
e.Int(s.ID)
|
|
}
|
|
{
|
|
|
|
e.FieldStart("user")
|
|
e.Str(s.User)
|
|
}
|
|
{
|
|
if s.Chara.Set {
|
|
e.FieldStart("chara")
|
|
s.Chara.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Skill.Set {
|
|
e.FieldStart("skill")
|
|
s.Skill.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Hp.Set {
|
|
e.FieldStart("hp")
|
|
s.Hp.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Attack.Set {
|
|
e.FieldStart("attack")
|
|
s.Attack.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Defense.Set {
|
|
e.FieldStart("defense")
|
|
s.Defense.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Critical.Set {
|
|
e.FieldStart("critical")
|
|
s.Critical.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Battle.Set {
|
|
e.FieldStart("battle")
|
|
s.Battle.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Win.Set {
|
|
e.FieldStart("win")
|
|
s.Win.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Day.Set {
|
|
e.FieldStart("day")
|
|
s.Day.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Percentage.Set {
|
|
e.FieldStart("percentage")
|
|
s.Percentage.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Limit.Set {
|
|
e.FieldStart("limit")
|
|
s.Limit.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Status.Set {
|
|
e.FieldStart("status")
|
|
s.Status.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Comment.Set {
|
|
e.FieldStart("comment")
|
|
s.Comment.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.CreatedAt.Set {
|
|
e.FieldStart("created_at")
|
|
s.CreatedAt.Encode(e, json.EncodeDateTime)
|
|
}
|
|
}
|
|
{
|
|
if s.Next.Set {
|
|
e.FieldStart("next")
|
|
s.Next.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.UpdatedAt.Set {
|
|
e.FieldStart("updated_at")
|
|
s.UpdatedAt.Encode(e, json.EncodeDateTime)
|
|
}
|
|
}
|
|
{
|
|
if s.URL.Set {
|
|
e.FieldStart("url")
|
|
s.URL.Encode(e)
|
|
}
|
|
}
|
|
}
|
|
|
|
var jsonFieldsNameOfUsersUpdate = [19]string{
|
|
0: "id",
|
|
1: "user",
|
|
2: "chara",
|
|
3: "skill",
|
|
4: "hp",
|
|
5: "attack",
|
|
6: "defense",
|
|
7: "critical",
|
|
8: "battle",
|
|
9: "win",
|
|
10: "day",
|
|
11: "percentage",
|
|
12: "limit",
|
|
13: "status",
|
|
14: "comment",
|
|
15: "created_at",
|
|
16: "next",
|
|
17: "updated_at",
|
|
18: "url",
|
|
}
|
|
|
|
// Decode decodes UsersUpdate from json.
|
|
func (s *UsersUpdate) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode UsersUpdate to nil")
|
|
}
|
|
var requiredBitSet [3]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 "user":
|
|
requiredBitSet[0] |= 1 << 1
|
|
if err := func() error {
|
|
v, err := d.Str()
|
|
s.User = string(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"user\"")
|
|
}
|
|
case "chara":
|
|
if err := func() error {
|
|
s.Chara.Reset()
|
|
if err := s.Chara.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"chara\"")
|
|
}
|
|
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 "hp":
|
|
if err := func() error {
|
|
s.Hp.Reset()
|
|
if err := s.Hp.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"hp\"")
|
|
}
|
|
case "attack":
|
|
if err := func() error {
|
|
s.Attack.Reset()
|
|
if err := s.Attack.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"attack\"")
|
|
}
|
|
case "defense":
|
|
if err := func() error {
|
|
s.Defense.Reset()
|
|
if err := s.Defense.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"defense\"")
|
|
}
|
|
case "critical":
|
|
if err := func() error {
|
|
s.Critical.Reset()
|
|
if err := s.Critical.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"critical\"")
|
|
}
|
|
case "battle":
|
|
if err := func() error {
|
|
s.Battle.Reset()
|
|
if err := s.Battle.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"battle\"")
|
|
}
|
|
case "win":
|
|
if err := func() error {
|
|
s.Win.Reset()
|
|
if err := s.Win.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"win\"")
|
|
}
|
|
case "day":
|
|
if err := func() error {
|
|
s.Day.Reset()
|
|
if err := s.Day.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"day\"")
|
|
}
|
|
case "percentage":
|
|
if err := func() error {
|
|
s.Percentage.Reset()
|
|
if err := s.Percentage.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"percentage\"")
|
|
}
|
|
case "limit":
|
|
if err := func() error {
|
|
s.Limit.Reset()
|
|
if err := s.Limit.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"limit\"")
|
|
}
|
|
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 "comment":
|
|
if err := func() error {
|
|
s.Comment.Reset()
|
|
if err := s.Comment.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"comment\"")
|
|
}
|
|
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 "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 "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 "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\"")
|
|
}
|
|
default:
|
|
return d.Skip()
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
return errors.Wrap(err, "decode UsersUpdate")
|
|
}
|
|
// Validate required fields.
|
|
var failures []validate.FieldError
|
|
for i, mask := range [3]uint8{
|
|
0b00000011,
|
|
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(jsonFieldsNameOfUsersUpdate) {
|
|
name = jsonFieldsNameOfUsersUpdate[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
|
|
}
|