// Code generated by ogen, DO NOT EDIT.
package gen
import (
"math/bits"
"strconv"
"github.com/go-faster/errors"
"github.com/go-faster/jx"
"github.com/ogen-go/ogen/validate"
)
// Encode implements json.Marshaler.
func (s *AdvisorsResponse) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *AdvisorsResponse) encodeFields(e *jx.Encoder) {
{
e.FieldStart("lints")
e.ArrStart()
for _, elem := range s.Lints {
elem.Encode(e)
}
e.ArrEnd()
}
}
var jsonFieldsNameOfAdvisorsResponse = [1]string{
0: "lints",
}
// Decode decodes AdvisorsResponse from json.
func (s *AdvisorsResponse) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode AdvisorsResponse to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "lints":
requiredBitSet[0] |= 1 << 0
if err := func() error {
s.Lints = make([]Lint, 0)
if err := d.Arr(func(d *jx.Decoder) error {
var elem Lint
if err := elem.Decode(d); err != nil {
return err
}
s.Lints = append(s.Lints, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"lints\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode AdvisorsResponse")
}
// 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(jsonFieldsNameOfAdvisorsResponse) {
name = jsonFieldsNameOfAdvisorsResponse[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 *AdvisorsResponse) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AdvisorsResponse) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *AnalyticsResponse) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *AnalyticsResponse) encodeFields(e *jx.Encoder) {
{
if s.Result.Set {
e.FieldStart("result")
s.Result.Encode(e)
}
}
{
if s.Error.Set {
e.FieldStart("error")
s.Error.Encode(e)
}
}
}
var jsonFieldsNameOfAnalyticsResponse = [2]string{
0: "result",
1: "error",
}
// Decode decodes AnalyticsResponse from json.
func (s *AnalyticsResponse) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode AnalyticsResponse to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "result":
if err := func() error {
s.Result.Reset()
if err := s.Result.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"result\"")
}
case "error":
if err := func() error {
s.Error.Reset()
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 AnalyticsResponse")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *AnalyticsResponse) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *AnalyticsResponse) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *ApiKey) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *ApiKey) encodeFields(e *jx.Encoder) {
{
if s.APIKey.Set {
e.FieldStart("api_key")
s.APIKey.Encode(e)
}
}
{
e.FieldStart("name")
e.Str(s.Name)
}
{
if s.Type.Set {
e.FieldStart("type")
s.Type.Encode(e)
}
}
}
var jsonFieldsNameOfApiKey = [3]string{
0: "api_key",
1: "name",
2: "type",
}
// Decode decodes ApiKey from json.
func (s *ApiKey) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode ApiKey to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "api_key":
if err := func() error {
s.APIKey.Reset()
if err := s.APIKey.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"api_key\"")
}
case "name":
requiredBitSet[0] |= 1 << 1
if err := func() error {
v, err := d.Str()
s.Name = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"name\"")
}
case "type":
if err := func() error {
s.Type.Reset()
if err := s.Type.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"type\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode ApiKey")
}
// Validate required fields.
var failures []validate.FieldError
for i, mask := range [1]uint8{
0b00000010,
} {
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(jsonFieldsNameOfApiKey) {
name = jsonFieldsNameOfApiKey[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 *ApiKey) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ApiKey) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *EdgeFunction) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *EdgeFunction) encodeFields(e *jx.Encoder) {
{
e.FieldStart("id")
e.Str(s.ID)
}
{
e.FieldStart("slug")
e.Str(s.Slug)
}
{
e.FieldStart("name")
e.Str(s.Name)
}
{
e.FieldStart("status")
s.Status.Encode(e)
}
{
e.FieldStart("version")
e.Int(s.Version)
}
{
e.FieldStart("created_at")
e.Int64(s.CreatedAt)
}
{
e.FieldStart("updated_at")
e.Int64(s.UpdatedAt)
}
{
if s.VerifyJwt.Set {
e.FieldStart("verify_jwt")
s.VerifyJwt.Encode(e)
}
}
{
if s.ImportMap.Set {
e.FieldStart("import_map")
s.ImportMap.Encode(e)
}
}
{
if s.EntrypointPath.Set {
e.FieldStart("entrypoint_path")
s.EntrypointPath.Encode(e)
}
}
{
if s.ImportMapPath.Set {
e.FieldStart("import_map_path")
s.ImportMapPath.Encode(e)
}
}
}
var jsonFieldsNameOfEdgeFunction = [11]string{
0: "id",
1: "slug",
2: "name",
3: "status",
4: "version",
5: "created_at",
6: "updated_at",
7: "verify_jwt",
8: "import_map",
9: "entrypoint_path",
10: "import_map_path",
}
// Decode decodes EdgeFunction from json.
func (s *EdgeFunction) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode EdgeFunction to nil")
}
var requiredBitSet [2]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "id":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Str()
s.ID = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"id\"")
}
case "slug":
requiredBitSet[0] |= 1 << 1
if err := func() error {
v, err := d.Str()
s.Slug = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"slug\"")
}
case "name":
requiredBitSet[0] |= 1 << 2
if err := func() error {
v, err := d.Str()
s.Name = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"name\"")
}
case "status":
requiredBitSet[0] |= 1 << 3
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 "version":
requiredBitSet[0] |= 1 << 4
if err := func() error {
v, err := d.Int()
s.Version = int(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"version\"")
}
case "created_at":
requiredBitSet[0] |= 1 << 5
if err := func() error {
v, err := d.Int64()
s.CreatedAt = int64(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"created_at\"")
}
case "updated_at":
requiredBitSet[0] |= 1 << 6
if err := func() error {
v, err := d.Int64()
s.UpdatedAt = int64(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"updated_at\"")
}
case "verify_jwt":
if err := func() error {
s.VerifyJwt.Reset()
if err := s.VerifyJwt.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"verify_jwt\"")
}
case "import_map":
if err := func() error {
s.ImportMap.Reset()
if err := s.ImportMap.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"import_map\"")
}
case "entrypoint_path":
if err := func() error {
s.EntrypointPath.Reset()
if err := s.EntrypointPath.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"entrypoint_path\"")
}
case "import_map_path":
if err := func() error {
s.ImportMapPath.Reset()
if err := s.ImportMapPath.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"import_map_path\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode EdgeFunction")
}
// Validate required fields.
var failures []validate.FieldError
for i, mask := range [2]uint8{
0b01111111,
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(jsonFieldsNameOfEdgeFunction) {
name = jsonFieldsNameOfEdgeFunction[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 *EdgeFunction) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *EdgeFunction) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode encodes EdgeFunctionStatus as json.
func (s EdgeFunctionStatus) Encode(e *jx.Encoder) {
e.Str(string(s))
}
// Decode decodes EdgeFunctionStatus from json.
func (s *EdgeFunctionStatus) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode EdgeFunctionStatus to nil")
}
v, err := d.StrBytes()
if err != nil {
return err
}
// Try to use constant string.
switch EdgeFunctionStatus(v) {
case EdgeFunctionStatusACTIVE:
*s = EdgeFunctionStatusACTIVE
case EdgeFunctionStatusREMOVED:
*s = EdgeFunctionStatusREMOVED
case EdgeFunctionStatusTHROTTLED:
*s = EdgeFunctionStatusTHROTTLED
default:
*s = EdgeFunctionStatus(v)
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s EdgeFunctionStatus) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *EdgeFunctionStatus) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *FeatureToggle) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *FeatureToggle) encodeFields(e *jx.Encoder) {
{
e.FieldStart("enabled")
e.Bool(s.Enabled)
}
}
var jsonFieldsNameOfFeatureToggle = [1]string{
0: "enabled",
}
// Decode decodes FeatureToggle from json.
func (s *FeatureToggle) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode FeatureToggle to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "enabled":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Bool()
s.Enabled = bool(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"enabled\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode FeatureToggle")
}
// 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(jsonFieldsNameOfFeatureToggle) {
name = jsonFieldsNameOfFeatureToggle[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 *FeatureToggle) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *FeatureToggle) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *Lint) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *Lint) encodeFields(e *jx.Encoder) {
{
e.FieldStart("name")
e.Str(s.Name)
}
{
e.FieldStart("title")
e.Str(s.Title)
}
{
e.FieldStart("level")
s.Level.Encode(e)
}
{
e.FieldStart("facing")
e.Str(s.Facing)
}
{
e.FieldStart("categories")
e.ArrStart()
for _, elem := range s.Categories {
e.Str(elem)
}
e.ArrEnd()
}
{
e.FieldStart("description")
e.Str(s.Description)
}
{
e.FieldStart("detail")
e.Str(s.Detail)
}
{
e.FieldStart("remediation")
e.Str(s.Remediation)
}
{
if s.Metadata.Set {
e.FieldStart("metadata")
s.Metadata.Encode(e)
}
}
{
e.FieldStart("cache_key")
e.Str(s.CacheKey)
}
}
var jsonFieldsNameOfLint = [10]string{
0: "name",
1: "title",
2: "level",
3: "facing",
4: "categories",
5: "description",
6: "detail",
7: "remediation",
8: "metadata",
9: "cache_key",
}
// Decode decodes Lint from json.
func (s *Lint) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode Lint to nil")
}
var requiredBitSet [2]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "name":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Str()
s.Name = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"name\"")
}
case "title":
requiredBitSet[0] |= 1 << 1
if err := func() error {
v, err := d.Str()
s.Title = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"title\"")
}
case "level":
requiredBitSet[0] |= 1 << 2
if err := func() error {
if err := s.Level.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"level\"")
}
case "facing":
requiredBitSet[0] |= 1 << 3
if err := func() error {
v, err := d.Str()
s.Facing = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"facing\"")
}
case "categories":
requiredBitSet[0] |= 1 << 4
if err := func() error {
s.Categories = make([]string, 0)
if err := d.Arr(func(d *jx.Decoder) error {
var elem string
v, err := d.Str()
elem = string(v)
if err != nil {
return err
}
s.Categories = append(s.Categories, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"categories\"")
}
case "description":
requiredBitSet[0] |= 1 << 5
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\"")
}
case "detail":
requiredBitSet[0] |= 1 << 6
if err := func() error {
v, err := d.Str()
s.Detail = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"detail\"")
}
case "remediation":
requiredBitSet[0] |= 1 << 7
if err := func() error {
v, err := d.Str()
s.Remediation = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"remediation\"")
}
case "metadata":
if err := func() error {
s.Metadata.Reset()
if err := s.Metadata.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"metadata\"")
}
case "cache_key":
requiredBitSet[1] |= 1 << 1
if err := func() error {
v, err := d.Str()
s.CacheKey = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"cache_key\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode Lint")
}
// Validate required fields.
var failures []validate.FieldError
for i, mask := range [2]uint8{
0b11111111,
0b00000010,
} {
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(jsonFieldsNameOfLint) {
name = jsonFieldsNameOfLint[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 *Lint) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Lint) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode encodes LintLevel as json.
func (s LintLevel) Encode(e *jx.Encoder) {
e.Str(string(s))
}
// Decode decodes LintLevel from json.
func (s *LintLevel) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode LintLevel to nil")
}
v, err := d.StrBytes()
if err != nil {
return err
}
// Try to use constant string.
switch LintLevel(v) {
case LintLevelERROR:
*s = LintLevelERROR
case LintLevelWARN:
*s = LintLevelWARN
case LintLevelINFO:
*s = LintLevelINFO
default:
*s = LintLevel(v)
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s LintLevel) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *LintLevel) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *LintMetadata) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *LintMetadata) encodeFields(e *jx.Encoder) {
{
if s.Schema.Set {
e.FieldStart("schema")
s.Schema.Encode(e)
}
}
{
if s.Name.Set {
e.FieldStart("name")
s.Name.Encode(e)
}
}
{
if s.Entity.Set {
e.FieldStart("entity")
s.Entity.Encode(e)
}
}
{
if s.Type.Set {
e.FieldStart("type")
s.Type.Encode(e)
}
}
}
var jsonFieldsNameOfLintMetadata = [4]string{
0: "schema",
1: "name",
2: "entity",
3: "type",
}
// Decode decodes LintMetadata from json.
func (s *LintMetadata) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode LintMetadata to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "schema":
if err := func() error {
s.Schema.Reset()
if err := s.Schema.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"schema\"")
}
case "name":
if err := func() error {
s.Name.Reset()
if err := s.Name.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"name\"")
}
case "entity":
if err := func() error {
s.Entity.Reset()
if err := s.Entity.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"entity\"")
}
case "type":
if err := func() error {
s.Type.Reset()
if err := s.Type.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"type\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode LintMetadata")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *LintMetadata) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *LintMetadata) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode encodes bool as json.
func (o OptBool) Encode(e *jx.Encoder) {
if !o.Set {
return
}
e.Bool(bool(o.Value))
}
// Decode decodes bool from json.
func (o *OptBool) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptBool to nil")
}
o.Set = true
v, err := d.Bool()
if err != nil {
return err
}
o.Value = bool(v)
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptBool) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptBool) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode encodes FeatureToggle as json.
func (o OptFeatureToggle) Encode(e *jx.Encoder) {
if !o.Set {
return
}
o.Value.Encode(e)
}
// Decode decodes FeatureToggle from json.
func (o *OptFeatureToggle) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptFeatureToggle to nil")
}
o.Set = true
if err := o.Value.Decode(d); err != nil {
return err
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptFeatureToggle) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptFeatureToggle) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode encodes LintMetadata as json.
func (o OptLintMetadata) Encode(e *jx.Encoder) {
if !o.Set {
return
}
o.Value.Encode(e)
}
// Decode decodes LintMetadata from json.
func (o *OptLintMetadata) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptLintMetadata to nil")
}
o.Set = true
if err := o.Value.Decode(d); err != nil {
return err
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptLintMetadata) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptLintMetadata) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode encodes []jx.Raw as json.
func (o OptNilAnyArray) Encode(e *jx.Encoder) {
if !o.Set {
return
}
if o.Null {
e.Null()
return
}
e.ArrStart()
for _, elem := range o.Value {
if len(elem) != 0 {
e.Raw(elem)
}
}
e.ArrEnd()
}
// Decode decodes []jx.Raw from json.
func (o *OptNilAnyArray) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptNilAnyArray to nil")
}
if d.Next() == jx.Null {
if err := d.Null(); err != nil {
return err
}
var v []jx.Raw
o.Value = v
o.Set = true
o.Null = true
return nil
}
o.Set = true
o.Null = false
o.Value = make([]jx.Raw, 0)
if err := d.Arr(func(d *jx.Decoder) error {
var elem jx.Raw
v, err := d.RawAppend(nil)
elem = jx.Raw(v)
if err != nil {
return err
}
o.Value = append(o.Value, elem)
return nil
}); err != nil {
return err
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptNilAnyArray) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptNilAnyArray) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode encodes string as json.
func (o OptNilString) Encode(e *jx.Encoder) {
if !o.Set {
return
}
if o.Null {
e.Null()
return
}
e.Str(string(o.Value))
}
// Decode decodes string from json.
func (o *OptNilString) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptNilString to nil")
}
if d.Next() == jx.Null {
if err := d.Null(); err != nil {
return err
}
var v string
o.Value = v
o.Set = true
o.Null = true
return nil
}
o.Set = true
o.Null = false
v, err := d.Str()
if err != nil {
return err
}
o.Value = string(v)
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptNilString) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptNilString) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode encodes StorageFeatures as json.
func (o OptStorageFeatures) Encode(e *jx.Encoder) {
if !o.Set {
return
}
o.Value.Encode(e)
}
// Decode decodes StorageFeatures from json.
func (o *OptStorageFeatures) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptStorageFeatures to nil")
}
o.Set = true
if err := o.Value.Decode(d); err != nil {
return err
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptStorageFeatures) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptStorageFeatures) 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 *Organization) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *Organization) encodeFields(e *jx.Encoder) {
{
e.FieldStart("id")
e.Str(s.ID)
}
{
e.FieldStart("slug")
e.Str(s.Slug)
}
{
e.FieldStart("name")
e.Str(s.Name)
}
}
var jsonFieldsNameOfOrganization = [3]string{
0: "id",
1: "slug",
2: "name",
}
// Decode decodes Organization from json.
func (s *Organization) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode Organization to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "id":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Str()
s.ID = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"id\"")
}
case "slug":
requiredBitSet[0] |= 1 << 1
if err := func() error {
v, err := d.Str()
s.Slug = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"slug\"")
}
case "name":
requiredBitSet[0] |= 1 << 2
if err := func() error {
v, err := d.Str()
s.Name = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"name\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode Organization")
}
// Validate required fields.
var failures []validate.FieldError
for i, mask := range [1]uint8{
0b00000111,
} {
if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
// Mask only required fields and check equality to mask using XOR.
//
// If XOR result is not zero, result is not equal to expected, so some fields are missed.
// Bits of fields which would be set are actually bits of missed fields.
missed := bits.OnesCount8(result)
for bitN := 0; bitN < missed; bitN++ {
bitIdx := bits.TrailingZeros8(result)
fieldIdx := i*8 + bitIdx
var name string
if fieldIdx < len(jsonFieldsNameOfOrganization) {
name = jsonFieldsNameOfOrganization[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 *Organization) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Organization) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *Project) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *Project) encodeFields(e *jx.Encoder) {
{
e.FieldStart("id")
e.Str(s.ID)
}
{
e.FieldStart("ref")
e.Str(s.Ref)
}
{
e.FieldStart("organization_id")
e.Str(s.OrganizationID)
}
{
e.FieldStart("organization_slug")
e.Str(s.OrganizationSlug)
}
{
e.FieldStart("name")
e.Str(s.Name)
}
{
e.FieldStart("region")
e.Str(s.Region)
}
{
e.FieldStart("created_at")
e.Str(s.CreatedAt)
}
{
e.FieldStart("status")
s.Status.Encode(e)
}
{
e.FieldStart("database")
s.Database.Encode(e)
}
}
var jsonFieldsNameOfProject = [9]string{
0: "id",
1: "ref",
2: "organization_id",
3: "organization_slug",
4: "name",
5: "region",
6: "created_at",
7: "status",
8: "database",
}
// Decode decodes Project from json.
func (s *Project) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode Project to nil")
}
var requiredBitSet [2]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "id":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Str()
s.ID = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"id\"")
}
case "ref":
requiredBitSet[0] |= 1 << 1
if err := func() error {
v, err := d.Str()
s.Ref = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ref\"")
}
case "organization_id":
requiredBitSet[0] |= 1 << 2
if err := func() error {
v, err := d.Str()
s.OrganizationID = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"organization_id\"")
}
case "organization_slug":
requiredBitSet[0] |= 1 << 3
if err := func() error {
v, err := d.Str()
s.OrganizationSlug = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"organization_slug\"")
}
case "name":
requiredBitSet[0] |= 1 << 4
if err := func() error {
v, err := d.Str()
s.Name = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"name\"")
}
case "region":
requiredBitSet[0] |= 1 << 5
if err := func() error {
v, err := d.Str()
s.Region = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"region\"")
}
case "created_at":
requiredBitSet[0] |= 1 << 6
if err := func() error {
v, err := d.Str()
s.CreatedAt = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"created_at\"")
}
case "status":
requiredBitSet[0] |= 1 << 7
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 "database":
requiredBitSet[1] |= 1 << 0
if err := func() error {
if err := s.Database.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"database\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode Project")
}
// Validate required fields.
var failures []validate.FieldError
for i, mask := range [2]uint8{
0b11111111,
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(jsonFieldsNameOfProject) {
name = jsonFieldsNameOfProject[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 *Project) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Project) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *ProjectDatabase) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *ProjectDatabase) encodeFields(e *jx.Encoder) {
{
e.FieldStart("host")
e.Str(s.Host)
}
{
e.FieldStart("version")
e.Str(s.Version)
}
{
e.FieldStart("postgres_engine")
e.Str(s.PostgresEngine)
}
{
e.FieldStart("release_channel")
e.Str(s.ReleaseChannel)
}
}
var jsonFieldsNameOfProjectDatabase = [4]string{
0: "host",
1: "version",
2: "postgres_engine",
3: "release_channel",
}
// Decode decodes ProjectDatabase from json.
func (s *ProjectDatabase) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode ProjectDatabase to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "host":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Str()
s.Host = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"host\"")
}
case "version":
requiredBitSet[0] |= 1 << 1
if err := func() error {
v, err := d.Str()
s.Version = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"version\"")
}
case "postgres_engine":
requiredBitSet[0] |= 1 << 2
if err := func() error {
v, err := d.Str()
s.PostgresEngine = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"postgres_engine\"")
}
case "release_channel":
requiredBitSet[0] |= 1 << 3
if err := func() error {
v, err := d.Str()
s.ReleaseChannel = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"release_channel\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode ProjectDatabase")
}
// 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(jsonFieldsNameOfProjectDatabase) {
name = jsonFieldsNameOfProjectDatabase[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 *ProjectDatabase) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ProjectDatabase) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode encodes ProjectStatus as json.
func (s ProjectStatus) Encode(e *jx.Encoder) {
e.Str(string(s))
}
// Decode decodes ProjectStatus from json.
func (s *ProjectStatus) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode ProjectStatus to nil")
}
v, err := d.StrBytes()
if err != nil {
return err
}
// Try to use constant string.
switch ProjectStatus(v) {
case ProjectStatusINACTIVE:
*s = ProjectStatusINACTIVE
case ProjectStatusACTIVEHEALTHY:
*s = ProjectStatusACTIVEHEALTHY
case ProjectStatusACTIVEUNHEALTHY:
*s = ProjectStatusACTIVEUNHEALTHY
case ProjectStatusCOMINGUP:
*s = ProjectStatusCOMINGUP
case ProjectStatusUNKNOWN:
*s = ProjectStatusUNKNOWN
case ProjectStatusGOINGDOWN:
*s = ProjectStatusGOINGDOWN
case ProjectStatusINITFAILED:
*s = ProjectStatusINITFAILED
case ProjectStatusREMOVED:
*s = ProjectStatusREMOVED
case ProjectStatusRESTORING:
*s = ProjectStatusRESTORING
case ProjectStatusUPGRADING:
*s = ProjectStatusUPGRADING
case ProjectStatusPAUSING:
*s = ProjectStatusPAUSING
case ProjectStatusRESTOREFAILED:
*s = ProjectStatusRESTOREFAILED
case ProjectStatusRESTARTING:
*s = ProjectStatusRESTARTING
case ProjectStatusPAUSEFAILED:
*s = ProjectStatusPAUSEFAILED
case ProjectStatusRESIZING:
*s = ProjectStatusRESIZING
default:
*s = ProjectStatus(v)
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s ProjectStatus) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ProjectStatus) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *RunQueryRequest) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *RunQueryRequest) encodeFields(e *jx.Encoder) {
{
e.FieldStart("query")
e.Str(s.Query)
}
}
var jsonFieldsNameOfRunQueryRequest = [1]string{
0: "query",
}
// Decode decodes RunQueryRequest from json.
func (s *RunQueryRequest) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode RunQueryRequest to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "query":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Str()
s.Query = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"query\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode RunQueryRequest")
}
// 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(jsonFieldsNameOfRunQueryRequest) {
name = jsonFieldsNameOfRunQueryRequest[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 *RunQueryRequest) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RunQueryRequest) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *StorageBucket) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *StorageBucket) encodeFields(e *jx.Encoder) {
{
e.FieldStart("id")
e.Str(s.ID)
}
{
e.FieldStart("name")
e.Str(s.Name)
}
{
e.FieldStart("owner")
e.Str(s.Owner)
}
{
e.FieldStart("created_at")
e.Str(s.CreatedAt)
}
{
e.FieldStart("updated_at")
e.Str(s.UpdatedAt)
}
{
e.FieldStart("public")
e.Bool(s.Public)
}
}
var jsonFieldsNameOfStorageBucket = [6]string{
0: "id",
1: "name",
2: "owner",
3: "created_at",
4: "updated_at",
5: "public",
}
// Decode decodes StorageBucket from json.
func (s *StorageBucket) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode StorageBucket to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "id":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Str()
s.ID = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"id\"")
}
case "name":
requiredBitSet[0] |= 1 << 1
if err := func() error {
v, err := d.Str()
s.Name = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"name\"")
}
case "owner":
requiredBitSet[0] |= 1 << 2
if err := func() error {
v, err := d.Str()
s.Owner = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"owner\"")
}
case "created_at":
requiredBitSet[0] |= 1 << 3
if err := func() error {
v, err := d.Str()
s.CreatedAt = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"created_at\"")
}
case "updated_at":
requiredBitSet[0] |= 1 << 4
if err := func() error {
v, err := d.Str()
s.UpdatedAt = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"updated_at\"")
}
case "public":
requiredBitSet[0] |= 1 << 5
if err := func() error {
v, err := d.Bool()
s.Public = bool(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"public\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode StorageBucket")
}
// Validate required fields.
var failures []validate.FieldError
for i, mask := range [1]uint8{
0b00111111,
} {
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(jsonFieldsNameOfStorageBucket) {
name = jsonFieldsNameOfStorageBucket[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 *StorageBucket) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *StorageBucket) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *StorageConfig) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *StorageConfig) encodeFields(e *jx.Encoder) {
{
e.FieldStart("fileSizeLimit")
e.Int64(s.FileSizeLimit)
}
{
if s.Features.Set {
e.FieldStart("features")
s.Features.Encode(e)
}
}
{
if s.MigrationVersion.Set {
e.FieldStart("migrationVersion")
s.MigrationVersion.Encode(e)
}
}
{
if s.DatabasePoolMode.Set {
e.FieldStart("databasePoolMode")
s.DatabasePoolMode.Encode(e)
}
}
}
var jsonFieldsNameOfStorageConfig = [4]string{
0: "fileSizeLimit",
1: "features",
2: "migrationVersion",
3: "databasePoolMode",
}
// Decode decodes StorageConfig from json.
func (s *StorageConfig) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode StorageConfig to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "fileSizeLimit":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Int64()
s.FileSizeLimit = int64(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"fileSizeLimit\"")
}
case "features":
if err := func() error {
s.Features.Reset()
if err := s.Features.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"features\"")
}
case "migrationVersion":
if err := func() error {
s.MigrationVersion.Reset()
if err := s.MigrationVersion.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"migrationVersion\"")
}
case "databasePoolMode":
if err := func() error {
s.DatabasePoolMode.Reset()
if err := s.DatabasePoolMode.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"databasePoolMode\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode StorageConfig")
}
// 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(jsonFieldsNameOfStorageConfig) {
name = jsonFieldsNameOfStorageConfig[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 *StorageConfig) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *StorageConfig) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *StorageFeatures) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *StorageFeatures) encodeFields(e *jx.Encoder) {
{
if s.ImageTransformation.Set {
e.FieldStart("imageTransformation")
s.ImageTransformation.Encode(e)
}
}
{
if s.S3Protocol.Set {
e.FieldStart("s3Protocol")
s.S3Protocol.Encode(e)
}
}
}
var jsonFieldsNameOfStorageFeatures = [2]string{
0: "imageTransformation",
1: "s3Protocol",
}
// Decode decodes StorageFeatures from json.
func (s *StorageFeatures) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode StorageFeatures to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "imageTransformation":
if err := func() error {
s.ImageTransformation.Reset()
if err := s.ImageTransformation.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"imageTransformation\"")
}
case "s3Protocol":
if err := func() error {
s.S3Protocol.Reset()
if err := s.S3Protocol.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"s3Protocol\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode StorageFeatures")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *StorageFeatures) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *StorageFeatures) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
