forked from gsn/predictor
1398 lines
33 KiB
Go
1398 lines
33 KiB
Go
// Code generated by ogen, DO NOT EDIT.
|
|
|
|
package rest
|
|
|
|
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 *Error) Encode(e *jx.Encoder) {
|
|
e.ObjStart()
|
|
s.encodeFields(e)
|
|
e.ObjEnd()
|
|
}
|
|
|
|
// encodeFields encodes fields.
|
|
func (s *Error) encodeFields(e *jx.Encoder) {
|
|
{
|
|
e.FieldStart("error")
|
|
s.Error.Encode(e)
|
|
}
|
|
}
|
|
|
|
var jsonFieldsNameOfError = [1]string{
|
|
0: "error",
|
|
}
|
|
|
|
// Decode decodes Error from json.
|
|
func (s *Error) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode Error to nil")
|
|
}
|
|
var requiredBitSet [1]uint8
|
|
|
|
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
|
|
switch string(k) {
|
|
case "error":
|
|
requiredBitSet[0] |= 1 << 0
|
|
if err := func() error {
|
|
if err := s.Error.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"error\"")
|
|
}
|
|
default:
|
|
return d.Skip()
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
return errors.Wrap(err, "decode Error")
|
|
}
|
|
// Validate required fields.
|
|
var failures []validate.FieldError
|
|
for i, mask := range [1]uint8{
|
|
0b00000001,
|
|
} {
|
|
if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
|
|
// Mask only required fields and check equality to mask using XOR.
|
|
//
|
|
// If XOR result is not zero, result is not equal to expected, so some fields are missed.
|
|
// Bits of fields which would be set are actually bits of missed fields.
|
|
missed := bits.OnesCount8(result)
|
|
for bitN := 0; bitN < missed; bitN++ {
|
|
bitIdx := bits.TrailingZeros8(result)
|
|
fieldIdx := i*8 + bitIdx
|
|
var name string
|
|
if fieldIdx < len(jsonFieldsNameOfError) {
|
|
name = jsonFieldsNameOfError[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 *Error) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *Error) UnmarshalJSON(data []byte) error {
|
|
d := jx.DecodeBytes(data)
|
|
return s.Decode(d)
|
|
}
|
|
|
|
// Encode implements json.Marshaler.
|
|
func (s *ErrorError) Encode(e *jx.Encoder) {
|
|
e.ObjStart()
|
|
s.encodeFields(e)
|
|
e.ObjEnd()
|
|
}
|
|
|
|
// encodeFields encodes fields.
|
|
func (s *ErrorError) encodeFields(e *jx.Encoder) {
|
|
{
|
|
e.FieldStart("type")
|
|
e.Str(s.Type)
|
|
}
|
|
{
|
|
e.FieldStart("description")
|
|
e.Str(s.Description)
|
|
}
|
|
}
|
|
|
|
var jsonFieldsNameOfErrorError = [2]string{
|
|
0: "type",
|
|
1: "description",
|
|
}
|
|
|
|
// Decode decodes ErrorError from json.
|
|
func (s *ErrorError) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode ErrorError to nil")
|
|
}
|
|
var requiredBitSet [1]uint8
|
|
|
|
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
|
|
switch string(k) {
|
|
case "type":
|
|
requiredBitSet[0] |= 1 << 0
|
|
if err := func() error {
|
|
v, err := d.Str()
|
|
s.Type = string(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"type\"")
|
|
}
|
|
case "description":
|
|
requiredBitSet[0] |= 1 << 1
|
|
if err := func() error {
|
|
v, err := d.Str()
|
|
s.Description = string(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"description\"")
|
|
}
|
|
default:
|
|
return d.Skip()
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
return errors.Wrap(err, "decode ErrorError")
|
|
}
|
|
// 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(jsonFieldsNameOfErrorError) {
|
|
name = jsonFieldsNameOfErrorError[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 *ErrorError) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *ErrorError) 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 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
|
|
}
|
|
|
|
// MarshalJSON implements stdjson.Marshaler.
|
|
func (s OptFloat64) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *OptFloat64) UnmarshalJSON(data []byte) error {
|
|
d := jx.DecodeBytes(data)
|
|
return s.Decode(d)
|
|
}
|
|
|
|
// Encode encodes PredictionResponseRequest as json.
|
|
func (o OptPredictionResponseRequest) Encode(e *jx.Encoder) {
|
|
if !o.Set {
|
|
return
|
|
}
|
|
o.Value.Encode(e)
|
|
}
|
|
|
|
// Decode decodes PredictionResponseRequest from json.
|
|
func (o *OptPredictionResponseRequest) Decode(d *jx.Decoder) error {
|
|
if o == nil {
|
|
return errors.New("invalid: unable to decode OptPredictionResponseRequest to nil")
|
|
}
|
|
o.Set = true
|
|
if err := o.Value.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// MarshalJSON implements stdjson.Marshaler.
|
|
func (s OptPredictionResponseRequest) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *OptPredictionResponseRequest) UnmarshalJSON(data []byte) error {
|
|
d := jx.DecodeBytes(data)
|
|
return s.Decode(d)
|
|
}
|
|
|
|
// Encode encodes PredictionResponseWarnings as json.
|
|
func (o OptPredictionResponseWarnings) Encode(e *jx.Encoder) {
|
|
if !o.Set {
|
|
return
|
|
}
|
|
o.Value.Encode(e)
|
|
}
|
|
|
|
// Decode decodes PredictionResponseWarnings from json.
|
|
func (o *OptPredictionResponseWarnings) Decode(d *jx.Decoder) error {
|
|
if o == nil {
|
|
return errors.New("invalid: unable to decode OptPredictionResponseWarnings to nil")
|
|
}
|
|
o.Set = true
|
|
o.Value = make(PredictionResponseWarnings)
|
|
if err := o.Value.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// MarshalJSON implements stdjson.Marshaler.
|
|
func (s OptPredictionResponseWarnings) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *OptPredictionResponseWarnings) 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 *PredictionResponse) Encode(e *jx.Encoder) {
|
|
e.ObjStart()
|
|
s.encodeFields(e)
|
|
e.ObjEnd()
|
|
}
|
|
|
|
// encodeFields encodes fields.
|
|
func (s *PredictionResponse) encodeFields(e *jx.Encoder) {
|
|
{
|
|
if s.Request.Set {
|
|
e.FieldStart("request")
|
|
s.Request.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
e.FieldStart("prediction")
|
|
e.ArrStart()
|
|
for _, elem := range s.Prediction {
|
|
elem.Encode(e)
|
|
}
|
|
e.ArrEnd()
|
|
}
|
|
{
|
|
e.FieldStart("metadata")
|
|
s.Metadata.Encode(e)
|
|
}
|
|
{
|
|
if s.Warnings.Set {
|
|
e.FieldStart("warnings")
|
|
s.Warnings.Encode(e)
|
|
}
|
|
}
|
|
}
|
|
|
|
var jsonFieldsNameOfPredictionResponse = [4]string{
|
|
0: "request",
|
|
1: "prediction",
|
|
2: "metadata",
|
|
3: "warnings",
|
|
}
|
|
|
|
// Decode decodes PredictionResponse from json.
|
|
func (s *PredictionResponse) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode PredictionResponse to nil")
|
|
}
|
|
var requiredBitSet [1]uint8
|
|
|
|
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
|
|
switch string(k) {
|
|
case "request":
|
|
if err := func() error {
|
|
s.Request.Reset()
|
|
if err := s.Request.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"request\"")
|
|
}
|
|
case "prediction":
|
|
requiredBitSet[0] |= 1 << 1
|
|
if err := func() error {
|
|
s.Prediction = make([]PredictionResponsePredictionItem, 0)
|
|
if err := d.Arr(func(d *jx.Decoder) error {
|
|
var elem PredictionResponsePredictionItem
|
|
if err := elem.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
s.Prediction = append(s.Prediction, elem)
|
|
return nil
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"prediction\"")
|
|
}
|
|
case "metadata":
|
|
requiredBitSet[0] |= 1 << 2
|
|
if err := func() error {
|
|
if err := s.Metadata.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"metadata\"")
|
|
}
|
|
case "warnings":
|
|
if err := func() error {
|
|
s.Warnings.Reset()
|
|
if err := s.Warnings.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"warnings\"")
|
|
}
|
|
default:
|
|
return d.Skip()
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
return errors.Wrap(err, "decode PredictionResponse")
|
|
}
|
|
// Validate required fields.
|
|
var failures []validate.FieldError
|
|
for i, mask := range [1]uint8{
|
|
0b00000110,
|
|
} {
|
|
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(jsonFieldsNameOfPredictionResponse) {
|
|
name = jsonFieldsNameOfPredictionResponse[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 *PredictionResponse) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *PredictionResponse) UnmarshalJSON(data []byte) error {
|
|
d := jx.DecodeBytes(data)
|
|
return s.Decode(d)
|
|
}
|
|
|
|
// Encode implements json.Marshaler.
|
|
func (s *PredictionResponseMetadata) Encode(e *jx.Encoder) {
|
|
e.ObjStart()
|
|
s.encodeFields(e)
|
|
e.ObjEnd()
|
|
}
|
|
|
|
// encodeFields encodes fields.
|
|
func (s *PredictionResponseMetadata) encodeFields(e *jx.Encoder) {
|
|
{
|
|
e.FieldStart("start_datetime")
|
|
json.EncodeDateTime(e, s.StartDatetime)
|
|
}
|
|
{
|
|
e.FieldStart("complete_datetime")
|
|
json.EncodeDateTime(e, s.CompleteDatetime)
|
|
}
|
|
}
|
|
|
|
var jsonFieldsNameOfPredictionResponseMetadata = [2]string{
|
|
0: "start_datetime",
|
|
1: "complete_datetime",
|
|
}
|
|
|
|
// Decode decodes PredictionResponseMetadata from json.
|
|
func (s *PredictionResponseMetadata) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode PredictionResponseMetadata to nil")
|
|
}
|
|
var requiredBitSet [1]uint8
|
|
|
|
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
|
|
switch string(k) {
|
|
case "start_datetime":
|
|
requiredBitSet[0] |= 1 << 0
|
|
if err := func() error {
|
|
v, err := json.DecodeDateTime(d)
|
|
s.StartDatetime = v
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"start_datetime\"")
|
|
}
|
|
case "complete_datetime":
|
|
requiredBitSet[0] |= 1 << 1
|
|
if err := func() error {
|
|
v, err := json.DecodeDateTime(d)
|
|
s.CompleteDatetime = v
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"complete_datetime\"")
|
|
}
|
|
default:
|
|
return d.Skip()
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
return errors.Wrap(err, "decode PredictionResponseMetadata")
|
|
}
|
|
// 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(jsonFieldsNameOfPredictionResponseMetadata) {
|
|
name = jsonFieldsNameOfPredictionResponseMetadata[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 *PredictionResponseMetadata) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *PredictionResponseMetadata) UnmarshalJSON(data []byte) error {
|
|
d := jx.DecodeBytes(data)
|
|
return s.Decode(d)
|
|
}
|
|
|
|
// Encode implements json.Marshaler.
|
|
func (s *PredictionResponsePredictionItem) Encode(e *jx.Encoder) {
|
|
e.ObjStart()
|
|
s.encodeFields(e)
|
|
e.ObjEnd()
|
|
}
|
|
|
|
// encodeFields encodes fields.
|
|
func (s *PredictionResponsePredictionItem) encodeFields(e *jx.Encoder) {
|
|
{
|
|
e.FieldStart("stage")
|
|
s.Stage.Encode(e)
|
|
}
|
|
{
|
|
e.FieldStart("trajectory")
|
|
e.ArrStart()
|
|
for _, elem := range s.Trajectory {
|
|
elem.Encode(e)
|
|
}
|
|
e.ArrEnd()
|
|
}
|
|
}
|
|
|
|
var jsonFieldsNameOfPredictionResponsePredictionItem = [2]string{
|
|
0: "stage",
|
|
1: "trajectory",
|
|
}
|
|
|
|
// Decode decodes PredictionResponsePredictionItem from json.
|
|
func (s *PredictionResponsePredictionItem) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode PredictionResponsePredictionItem to nil")
|
|
}
|
|
var requiredBitSet [1]uint8
|
|
|
|
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
|
|
switch string(k) {
|
|
case "stage":
|
|
requiredBitSet[0] |= 1 << 0
|
|
if err := func() error {
|
|
if err := s.Stage.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"stage\"")
|
|
}
|
|
case "trajectory":
|
|
requiredBitSet[0] |= 1 << 1
|
|
if err := func() error {
|
|
s.Trajectory = make([]PredictionResponsePredictionItemTrajectoryItem, 0)
|
|
if err := d.Arr(func(d *jx.Decoder) error {
|
|
var elem PredictionResponsePredictionItemTrajectoryItem
|
|
if err := elem.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
s.Trajectory = append(s.Trajectory, elem)
|
|
return nil
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"trajectory\"")
|
|
}
|
|
default:
|
|
return d.Skip()
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
return errors.Wrap(err, "decode PredictionResponsePredictionItem")
|
|
}
|
|
// 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(jsonFieldsNameOfPredictionResponsePredictionItem) {
|
|
name = jsonFieldsNameOfPredictionResponsePredictionItem[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 *PredictionResponsePredictionItem) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *PredictionResponsePredictionItem) UnmarshalJSON(data []byte) error {
|
|
d := jx.DecodeBytes(data)
|
|
return s.Decode(d)
|
|
}
|
|
|
|
// Encode encodes PredictionResponsePredictionItemStage as json.
|
|
func (s PredictionResponsePredictionItemStage) Encode(e *jx.Encoder) {
|
|
e.Str(string(s))
|
|
}
|
|
|
|
// Decode decodes PredictionResponsePredictionItemStage from json.
|
|
func (s *PredictionResponsePredictionItemStage) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode PredictionResponsePredictionItemStage to nil")
|
|
}
|
|
v, err := d.StrBytes()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
// Try to use constant string.
|
|
switch PredictionResponsePredictionItemStage(v) {
|
|
case PredictionResponsePredictionItemStageAscent:
|
|
*s = PredictionResponsePredictionItemStageAscent
|
|
case PredictionResponsePredictionItemStageDescent:
|
|
*s = PredictionResponsePredictionItemStageDescent
|
|
case PredictionResponsePredictionItemStageFloat:
|
|
*s = PredictionResponsePredictionItemStageFloat
|
|
default:
|
|
*s = PredictionResponsePredictionItemStage(v)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// MarshalJSON implements stdjson.Marshaler.
|
|
func (s PredictionResponsePredictionItemStage) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *PredictionResponsePredictionItemStage) UnmarshalJSON(data []byte) error {
|
|
d := jx.DecodeBytes(data)
|
|
return s.Decode(d)
|
|
}
|
|
|
|
// Encode implements json.Marshaler.
|
|
func (s *PredictionResponsePredictionItemTrajectoryItem) Encode(e *jx.Encoder) {
|
|
e.ObjStart()
|
|
s.encodeFields(e)
|
|
e.ObjEnd()
|
|
}
|
|
|
|
// encodeFields encodes fields.
|
|
func (s *PredictionResponsePredictionItemTrajectoryItem) encodeFields(e *jx.Encoder) {
|
|
{
|
|
e.FieldStart("datetime")
|
|
json.EncodeDateTime(e, s.Datetime)
|
|
}
|
|
{
|
|
e.FieldStart("latitude")
|
|
e.Float64(s.Latitude)
|
|
}
|
|
{
|
|
e.FieldStart("longitude")
|
|
e.Float64(s.Longitude)
|
|
}
|
|
{
|
|
e.FieldStart("altitude")
|
|
e.Float64(s.Altitude)
|
|
}
|
|
}
|
|
|
|
var jsonFieldsNameOfPredictionResponsePredictionItemTrajectoryItem = [4]string{
|
|
0: "datetime",
|
|
1: "latitude",
|
|
2: "longitude",
|
|
3: "altitude",
|
|
}
|
|
|
|
// Decode decodes PredictionResponsePredictionItemTrajectoryItem from json.
|
|
func (s *PredictionResponsePredictionItemTrajectoryItem) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode PredictionResponsePredictionItemTrajectoryItem to nil")
|
|
}
|
|
var requiredBitSet [1]uint8
|
|
|
|
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
|
|
switch string(k) {
|
|
case "datetime":
|
|
requiredBitSet[0] |= 1 << 0
|
|
if err := func() error {
|
|
v, err := json.DecodeDateTime(d)
|
|
s.Datetime = v
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"datetime\"")
|
|
}
|
|
case "latitude":
|
|
requiredBitSet[0] |= 1 << 1
|
|
if err := func() error {
|
|
v, err := d.Float64()
|
|
s.Latitude = float64(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"latitude\"")
|
|
}
|
|
case "longitude":
|
|
requiredBitSet[0] |= 1 << 2
|
|
if err := func() error {
|
|
v, err := d.Float64()
|
|
s.Longitude = float64(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"longitude\"")
|
|
}
|
|
case "altitude":
|
|
requiredBitSet[0] |= 1 << 3
|
|
if err := func() error {
|
|
v, err := d.Float64()
|
|
s.Altitude = float64(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"altitude\"")
|
|
}
|
|
default:
|
|
return d.Skip()
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
return errors.Wrap(err, "decode PredictionResponsePredictionItemTrajectoryItem")
|
|
}
|
|
// Validate required fields.
|
|
var failures []validate.FieldError
|
|
for i, mask := range [1]uint8{
|
|
0b00001111,
|
|
} {
|
|
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(jsonFieldsNameOfPredictionResponsePredictionItemTrajectoryItem) {
|
|
name = jsonFieldsNameOfPredictionResponsePredictionItemTrajectoryItem[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 *PredictionResponsePredictionItemTrajectoryItem) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *PredictionResponsePredictionItemTrajectoryItem) UnmarshalJSON(data []byte) error {
|
|
d := jx.DecodeBytes(data)
|
|
return s.Decode(d)
|
|
}
|
|
|
|
// Encode implements json.Marshaler.
|
|
func (s *PredictionResponseRequest) Encode(e *jx.Encoder) {
|
|
e.ObjStart()
|
|
s.encodeFields(e)
|
|
e.ObjEnd()
|
|
}
|
|
|
|
// encodeFields encodes fields.
|
|
func (s *PredictionResponseRequest) encodeFields(e *jx.Encoder) {
|
|
{
|
|
if s.Dataset.Set {
|
|
e.FieldStart("dataset")
|
|
s.Dataset.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.LaunchLatitude.Set {
|
|
e.FieldStart("launch_latitude")
|
|
s.LaunchLatitude.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.LaunchLongitude.Set {
|
|
e.FieldStart("launch_longitude")
|
|
s.LaunchLongitude.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.LaunchDatetime.Set {
|
|
e.FieldStart("launch_datetime")
|
|
s.LaunchDatetime.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.LaunchAltitude.Set {
|
|
e.FieldStart("launch_altitude")
|
|
s.LaunchAltitude.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.Profile.Set {
|
|
e.FieldStart("profile")
|
|
s.Profile.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.AscentRate.Set {
|
|
e.FieldStart("ascent_rate")
|
|
s.AscentRate.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.BurstAltitude.Set {
|
|
e.FieldStart("burst_altitude")
|
|
s.BurstAltitude.Encode(e)
|
|
}
|
|
}
|
|
{
|
|
if s.DescentRate.Set {
|
|
e.FieldStart("descent_rate")
|
|
s.DescentRate.Encode(e)
|
|
}
|
|
}
|
|
}
|
|
|
|
var jsonFieldsNameOfPredictionResponseRequest = [9]string{
|
|
0: "dataset",
|
|
1: "launch_latitude",
|
|
2: "launch_longitude",
|
|
3: "launch_datetime",
|
|
4: "launch_altitude",
|
|
5: "profile",
|
|
6: "ascent_rate",
|
|
7: "burst_altitude",
|
|
8: "descent_rate",
|
|
}
|
|
|
|
// Decode decodes PredictionResponseRequest from json.
|
|
func (s *PredictionResponseRequest) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode PredictionResponseRequest to nil")
|
|
}
|
|
|
|
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
|
|
switch string(k) {
|
|
case "dataset":
|
|
if err := func() error {
|
|
s.Dataset.Reset()
|
|
if err := s.Dataset.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"dataset\"")
|
|
}
|
|
case "launch_latitude":
|
|
if err := func() error {
|
|
s.LaunchLatitude.Reset()
|
|
if err := s.LaunchLatitude.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"launch_latitude\"")
|
|
}
|
|
case "launch_longitude":
|
|
if err := func() error {
|
|
s.LaunchLongitude.Reset()
|
|
if err := s.LaunchLongitude.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"launch_longitude\"")
|
|
}
|
|
case "launch_datetime":
|
|
if err := func() error {
|
|
s.LaunchDatetime.Reset()
|
|
if err := s.LaunchDatetime.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"launch_datetime\"")
|
|
}
|
|
case "launch_altitude":
|
|
if err := func() error {
|
|
s.LaunchAltitude.Reset()
|
|
if err := s.LaunchAltitude.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"launch_altitude\"")
|
|
}
|
|
case "profile":
|
|
if err := func() error {
|
|
s.Profile.Reset()
|
|
if err := s.Profile.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"profile\"")
|
|
}
|
|
case "ascent_rate":
|
|
if err := func() error {
|
|
s.AscentRate.Reset()
|
|
if err := s.AscentRate.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"ascent_rate\"")
|
|
}
|
|
case "burst_altitude":
|
|
if err := func() error {
|
|
s.BurstAltitude.Reset()
|
|
if err := s.BurstAltitude.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"burst_altitude\"")
|
|
}
|
|
case "descent_rate":
|
|
if err := func() error {
|
|
s.DescentRate.Reset()
|
|
if err := s.DescentRate.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"descent_rate\"")
|
|
}
|
|
default:
|
|
return d.Skip()
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
return errors.Wrap(err, "decode PredictionResponseRequest")
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// MarshalJSON implements stdjson.Marshaler.
|
|
func (s *PredictionResponseRequest) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *PredictionResponseRequest) UnmarshalJSON(data []byte) error {
|
|
d := jx.DecodeBytes(data)
|
|
return s.Decode(d)
|
|
}
|
|
|
|
// Encode implements json.Marshaler.
|
|
func (s PredictionResponseWarnings) Encode(e *jx.Encoder) {
|
|
e.ObjStart()
|
|
s.encodeFields(e)
|
|
e.ObjEnd()
|
|
}
|
|
|
|
// encodeFields implements json.Marshaler.
|
|
func (s PredictionResponseWarnings) encodeFields(e *jx.Encoder) {
|
|
for k, elem := range s {
|
|
e.FieldStart(k)
|
|
|
|
if len(elem) != 0 {
|
|
e.Raw(elem)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Decode decodes PredictionResponseWarnings from json.
|
|
func (s *PredictionResponseWarnings) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode PredictionResponseWarnings to nil")
|
|
}
|
|
m := s.init()
|
|
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
|
|
var elem jx.Raw
|
|
if err := func() error {
|
|
v, err := d.RawAppend(nil)
|
|
elem = jx.Raw(v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrapf(err, "decode field %q", k)
|
|
}
|
|
m[string(k)] = elem
|
|
return nil
|
|
}); err != nil {
|
|
return errors.Wrap(err, "decode PredictionResponseWarnings")
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// MarshalJSON implements stdjson.Marshaler.
|
|
func (s PredictionResponseWarnings) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *PredictionResponseWarnings) UnmarshalJSON(data []byte) error {
|
|
d := jx.DecodeBytes(data)
|
|
return s.Decode(d)
|
|
}
|
|
|
|
// Encode implements json.Marshaler.
|
|
func (s *ReadinessResponse) Encode(e *jx.Encoder) {
|
|
e.ObjStart()
|
|
s.encodeFields(e)
|
|
e.ObjEnd()
|
|
}
|
|
|
|
// encodeFields encodes fields.
|
|
func (s *ReadinessResponse) encodeFields(e *jx.Encoder) {
|
|
{
|
|
e.FieldStart("status")
|
|
s.Status.Encode(e)
|
|
}
|
|
{
|
|
if s.DatasetTime.Set {
|
|
e.FieldStart("dataset_time")
|
|
s.DatasetTime.Encode(e, json.EncodeDateTime)
|
|
}
|
|
}
|
|
{
|
|
if s.ErrorMessage.Set {
|
|
e.FieldStart("error_message")
|
|
s.ErrorMessage.Encode(e)
|
|
}
|
|
}
|
|
}
|
|
|
|
var jsonFieldsNameOfReadinessResponse = [3]string{
|
|
0: "status",
|
|
1: "dataset_time",
|
|
2: "error_message",
|
|
}
|
|
|
|
// Decode decodes ReadinessResponse from json.
|
|
func (s *ReadinessResponse) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode ReadinessResponse to nil")
|
|
}
|
|
var requiredBitSet [1]uint8
|
|
|
|
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
|
|
switch string(k) {
|
|
case "status":
|
|
requiredBitSet[0] |= 1 << 0
|
|
if err := func() error {
|
|
if err := s.Status.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"status\"")
|
|
}
|
|
case "dataset_time":
|
|
if err := func() error {
|
|
s.DatasetTime.Reset()
|
|
if err := s.DatasetTime.Decode(d, json.DecodeDateTime); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"dataset_time\"")
|
|
}
|
|
case "error_message":
|
|
if err := func() error {
|
|
s.ErrorMessage.Reset()
|
|
if err := s.ErrorMessage.Decode(d); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}(); err != nil {
|
|
return errors.Wrap(err, "decode field \"error_message\"")
|
|
}
|
|
default:
|
|
return d.Skip()
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
return errors.Wrap(err, "decode ReadinessResponse")
|
|
}
|
|
// Validate required fields.
|
|
var failures []validate.FieldError
|
|
for i, mask := range [1]uint8{
|
|
0b00000001,
|
|
} {
|
|
if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
|
|
// Mask only required fields and check equality to mask using XOR.
|
|
//
|
|
// If XOR result is not zero, result is not equal to expected, so some fields are missed.
|
|
// Bits of fields which would be set are actually bits of missed fields.
|
|
missed := bits.OnesCount8(result)
|
|
for bitN := 0; bitN < missed; bitN++ {
|
|
bitIdx := bits.TrailingZeros8(result)
|
|
fieldIdx := i*8 + bitIdx
|
|
var name string
|
|
if fieldIdx < len(jsonFieldsNameOfReadinessResponse) {
|
|
name = jsonFieldsNameOfReadinessResponse[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 *ReadinessResponse) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *ReadinessResponse) UnmarshalJSON(data []byte) error {
|
|
d := jx.DecodeBytes(data)
|
|
return s.Decode(d)
|
|
}
|
|
|
|
// Encode encodes ReadinessResponseStatus as json.
|
|
func (s ReadinessResponseStatus) Encode(e *jx.Encoder) {
|
|
e.Str(string(s))
|
|
}
|
|
|
|
// Decode decodes ReadinessResponseStatus from json.
|
|
func (s *ReadinessResponseStatus) Decode(d *jx.Decoder) error {
|
|
if s == nil {
|
|
return errors.New("invalid: unable to decode ReadinessResponseStatus to nil")
|
|
}
|
|
v, err := d.StrBytes()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
// Try to use constant string.
|
|
switch ReadinessResponseStatus(v) {
|
|
case ReadinessResponseStatusOk:
|
|
*s = ReadinessResponseStatusOk
|
|
case ReadinessResponseStatusNotReady:
|
|
*s = ReadinessResponseStatusNotReady
|
|
case ReadinessResponseStatusError:
|
|
*s = ReadinessResponseStatusError
|
|
default:
|
|
*s = ReadinessResponseStatus(v)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// MarshalJSON implements stdjson.Marshaler.
|
|
func (s ReadinessResponseStatus) MarshalJSON() ([]byte, error) {
|
|
e := jx.Encoder{}
|
|
s.Encode(&e)
|
|
return e.Bytes(), nil
|
|
}
|
|
|
|
// UnmarshalJSON implements stdjson.Unmarshaler.
|
|
func (s *ReadinessResponseStatus) UnmarshalJSON(data []byte) error {
|
|
d := jx.DecodeBytes(data)
|
|
return s.Decode(d)
|
|
}
|