// Code generated by ogen, DO NOT EDIT.
package gen
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 *Branch) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *Branch) encodeFields(e *jx.Encoder) {
{
e.FieldStart("name")
e.Str(s.Name)
}
{
if s.Protected.Set {
e.FieldStart("protected")
s.Protected.Encode(e)
}
}
}
var jsonFieldsNameOfBranch = [2]string{
0: "name",
1: "protected",
}
// Decode decodes Branch from json.
func (s *Branch) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode Branch to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "name":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Str()
s.Name = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"name\"")
}
case "protected":
if err := func() error {
s.Protected.Reset()
if err := s.Protected.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"protected\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode Branch")
}
// 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(jsonFieldsNameOfBranch) {
name = jsonFieldsNameOfBranch[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 *Branch) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Branch) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *Commit) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *Commit) encodeFields(e *jx.Encoder) {
{
e.FieldStart("sha")
e.Str(s.Sha)
}
{
e.FieldStart("html_url")
json.EncodeURI(e, s.HTMLURL)
}
{
if s.Commit.Set {
e.FieldStart("commit")
s.Commit.Encode(e)
}
}
{
if s.Author.Set {
e.FieldStart("author")
s.Author.Encode(e)
}
}
}
var jsonFieldsNameOfCommit = [4]string{
0: "sha",
1: "html_url",
2: "commit",
3: "author",
}
// Decode decodes Commit from json.
func (s *Commit) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode Commit to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "sha":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Str()
s.Sha = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"sha\"")
}
case "html_url":
requiredBitSet[0] |= 1 << 1
if err := func() error {
v, err := json.DecodeURI(d)
s.HTMLURL = v
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"html_url\"")
}
case "commit":
if err := func() error {
s.Commit.Reset()
if err := s.Commit.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"commit\"")
}
case "author":
if err := func() error {
s.Author.Reset()
if err := s.Author.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"author\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode Commit")
}
// 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(jsonFieldsNameOfCommit) {
name = jsonFieldsNameOfCommit[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 *Commit) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Commit) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *CommitCommit) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *CommitCommit) encodeFields(e *jx.Encoder) {
{
if s.Message.Set {
e.FieldStart("message")
s.Message.Encode(e)
}
}
{
if s.Author.Set {
e.FieldStart("author")
s.Author.Encode(e)
}
}
}
var jsonFieldsNameOfCommitCommit = [2]string{
0: "message",
1: "author",
}
// Decode decodes CommitCommit from json.
func (s *CommitCommit) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode CommitCommit to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "message":
if err := func() error {
s.Message.Reset()
if err := s.Message.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"message\"")
}
case "author":
if err := func() error {
s.Author.Reset()
if err := s.Author.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"author\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode CommitCommit")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *CommitCommit) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CommitCommit) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *CommitCommitAuthor) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *CommitCommitAuthor) encodeFields(e *jx.Encoder) {
{
if s.Name.Set {
e.FieldStart("name")
s.Name.Encode(e)
}
}
{
if s.Date.Set {
e.FieldStart("date")
s.Date.Encode(e, json.EncodeDateTime)
}
}
}
var jsonFieldsNameOfCommitCommitAuthor = [2]string{
0: "name",
1: "date",
}
// Decode decodes CommitCommitAuthor from json.
func (s *CommitCommitAuthor) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode CommitCommitAuthor to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "name":
if err := func() error {
s.Name.Reset()
if err := s.Name.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"name\"")
}
case "date":
if err := func() error {
s.Date.Reset()
if err := s.Date.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"date\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode CommitCommitAuthor")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *CommitCommitAuthor) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CommitCommitAuthor) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *CreateCommentRequest) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *CreateCommentRequest) encodeFields(e *jx.Encoder) {
{
e.FieldStart("body")
e.Str(s.Body)
}
}
var jsonFieldsNameOfCreateCommentRequest = [1]string{
0: "body",
}
// Decode decodes CreateCommentRequest from json.
func (s *CreateCommentRequest) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode CreateCommentRequest to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "body":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Str()
s.Body = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"body\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode CreateCommentRequest")
}
// 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(jsonFieldsNameOfCreateCommentRequest) {
name = jsonFieldsNameOfCreateCommentRequest[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 *CreateCommentRequest) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CreateCommentRequest) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *CreateIssueRequest) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *CreateIssueRequest) encodeFields(e *jx.Encoder) {
{
e.FieldStart("title")
e.Str(s.Title)
}
{
if s.Body.Set {
e.FieldStart("body")
s.Body.Encode(e)
}
}
{
if s.Labels != nil {
e.FieldStart("labels")
e.ArrStart()
for _, elem := range s.Labels {
e.Str(elem)
}
e.ArrEnd()
}
}
{
if s.Assignees != nil {
e.FieldStart("assignees")
e.ArrStart()
for _, elem := range s.Assignees {
e.Str(elem)
}
e.ArrEnd()
}
}
}
var jsonFieldsNameOfCreateIssueRequest = [4]string{
0: "title",
1: "body",
2: "labels",
3: "assignees",
}
// Decode decodes CreateIssueRequest from json.
func (s *CreateIssueRequest) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode CreateIssueRequest to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "title":
requiredBitSet[0] |= 1 << 0
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 "body":
if err := func() error {
s.Body.Reset()
if err := s.Body.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"body\"")
}
case "labels":
if err := func() error {
s.Labels = 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.Labels = append(s.Labels, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"labels\"")
}
case "assignees":
if err := func() error {
s.Assignees = 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.Assignees = append(s.Assignees, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"assignees\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode CreateIssueRequest")
}
// 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(jsonFieldsNameOfCreateIssueRequest) {
name = jsonFieldsNameOfCreateIssueRequest[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 *CreateIssueRequest) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CreateIssueRequest) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *CreatePRRequest) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *CreatePRRequest) encodeFields(e *jx.Encoder) {
{
e.FieldStart("title")
e.Str(s.Title)
}
{
e.FieldStart("head")
e.Str(s.Head)
}
{
e.FieldStart("base")
e.Str(s.Base)
}
{
if s.Body.Set {
e.FieldStart("body")
s.Body.Encode(e)
}
}
{
if s.Draft.Set {
e.FieldStart("draft")
s.Draft.Encode(e)
}
}
}
var jsonFieldsNameOfCreatePRRequest = [5]string{
0: "title",
1: "head",
2: "base",
3: "body",
4: "draft",
}
// Decode decodes CreatePRRequest from json.
func (s *CreatePRRequest) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode CreatePRRequest to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "title":
requiredBitSet[0] |= 1 << 0
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 "head":
requiredBitSet[0] |= 1 << 1
if err := func() error {
v, err := d.Str()
s.Head = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"head\"")
}
case "base":
requiredBitSet[0] |= 1 << 2
if err := func() error {
v, err := d.Str()
s.Base = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"base\"")
}
case "body":
if err := func() error {
s.Body.Reset()
if err := s.Body.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"body\"")
}
case "draft":
if err := func() error {
s.Draft.Reset()
if err := s.Draft.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"draft\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode CreatePRRequest")
}
// 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(jsonFieldsNameOfCreatePRRequest) {
name = jsonFieldsNameOfCreatePRRequest[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 *CreatePRRequest) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CreatePRRequest) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *FileContent) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *FileContent) encodeFields(e *jx.Encoder) {
{
e.FieldStart("name")
e.Str(s.Name)
}
{
e.FieldStart("path")
e.Str(s.Path)
}
{
if s.Sha.Set {
e.FieldStart("sha")
s.Sha.Encode(e)
}
}
{
if s.Size.Set {
e.FieldStart("size")
s.Size.Encode(e)
}
}
{
e.FieldStart("type")
e.Str(s.Type)
}
{
if s.Content.Set {
e.FieldStart("content")
s.Content.Encode(e)
}
}
{
if s.Encoding.Set {
e.FieldStart("encoding")
s.Encoding.Encode(e)
}
}
{
if s.HTMLURL.Set {
e.FieldStart("html_url")
s.HTMLURL.Encode(e)
}
}
}
var jsonFieldsNameOfFileContent = [8]string{
0: "name",
1: "path",
2: "sha",
3: "size",
4: "type",
5: "content",
6: "encoding",
7: "html_url",
}
// Decode decodes FileContent from json.
func (s *FileContent) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode FileContent to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "name":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Str()
s.Name = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"name\"")
}
case "path":
requiredBitSet[0] |= 1 << 1
if err := func() error {
v, err := d.Str()
s.Path = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"path\"")
}
case "sha":
if err := func() error {
s.Sha.Reset()
if err := s.Sha.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"sha\"")
}
case "size":
if err := func() error {
s.Size.Reset()
if err := s.Size.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"size\"")
}
case "type":
requiredBitSet[0] |= 1 << 4
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 "content":
if err := func() error {
s.Content.Reset()
if err := s.Content.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"content\"")
}
case "encoding":
if err := func() error {
s.Encoding.Reset()
if err := s.Encoding.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"encoding\"")
}
case "html_url":
if err := func() error {
s.HTMLURL.Reset()
if err := s.HTMLURL.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"html_url\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode FileContent")
}
// Validate required fields.
var failures []validate.FieldError
for i, mask := range [1]uint8{
0b00010011,
} {
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(jsonFieldsNameOfFileContent) {
name = jsonFieldsNameOfFileContent[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 *FileContent) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *FileContent) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *Issue) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *Issue) encodeFields(e *jx.Encoder) {
{
e.FieldStart("id")
e.Int64(s.ID)
}
{
e.FieldStart("number")
e.Int(s.Number)
}
{
e.FieldStart("title")
e.Str(s.Title)
}
{
e.FieldStart("state")
e.Str(s.State)
}
{
if s.Body.Set {
e.FieldStart("body")
s.Body.Encode(e)
}
}
{
e.FieldStart("html_url")
json.EncodeURI(e, s.HTMLURL)
}
{
if s.User.Set {
e.FieldStart("user")
s.User.Encode(e)
}
}
{
if s.Labels != nil {
e.FieldStart("labels")
e.ArrStart()
for _, elem := range s.Labels {
elem.Encode(e)
}
e.ArrEnd()
}
}
{
if s.Assignees != nil {
e.FieldStart("assignees")
e.ArrStart()
for _, elem := range s.Assignees {
elem.Encode(e)
}
e.ArrEnd()
}
}
{
if s.CreatedAt.Set {
e.FieldStart("created_at")
s.CreatedAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.UpdatedAt.Set {
e.FieldStart("updated_at")
s.UpdatedAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.ClosedAt.Set {
e.FieldStart("closed_at")
s.ClosedAt.Encode(e, json.EncodeDateTime)
}
}
}
var jsonFieldsNameOfIssue = [12]string{
0: "id",
1: "number",
2: "title",
3: "state",
4: "body",
5: "html_url",
6: "user",
7: "labels",
8: "assignees",
9: "created_at",
10: "updated_at",
11: "closed_at",
}
// Decode decodes Issue from json.
func (s *Issue) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode Issue 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.Int64()
s.ID = int64(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"id\"")
}
case "number":
requiredBitSet[0] |= 1 << 1
if err := func() error {
v, err := d.Int()
s.Number = int(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"number\"")
}
case "title":
requiredBitSet[0] |= 1 << 2
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 "state":
requiredBitSet[0] |= 1 << 3
if err := func() error {
v, err := d.Str()
s.State = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"state\"")
}
case "body":
if err := func() error {
s.Body.Reset()
if err := s.Body.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"body\"")
}
case "html_url":
requiredBitSet[0] |= 1 << 5
if err := func() error {
v, err := json.DecodeURI(d)
s.HTMLURL = v
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"html_url\"")
}
case "user":
if err := func() error {
s.User.Reset()
if err := s.User.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"user\"")
}
case "labels":
if err := func() error {
s.Labels = make([]Label, 0)
if err := d.Arr(func(d *jx.Decoder) error {
var elem Label
if err := elem.Decode(d); err != nil {
return err
}
s.Labels = append(s.Labels, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"labels\"")
}
case "assignees":
if err := func() error {
s.Assignees = make([]IssueUser, 0)
if err := d.Arr(func(d *jx.Decoder) error {
var elem IssueUser
if err := elem.Decode(d); err != nil {
return err
}
s.Assignees = append(s.Assignees, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"assignees\"")
}
case "created_at":
if err := func() error {
s.CreatedAt.Reset()
if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"created_at\"")
}
case "updated_at":
if err := func() error {
s.UpdatedAt.Reset()
if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"updated_at\"")
}
case "closed_at":
if err := func() error {
s.ClosedAt.Reset()
if err := s.ClosedAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"closed_at\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode Issue")
}
// Validate required fields.
var failures []validate.FieldError
for i, mask := range [2]uint8{
0b00101111,
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(jsonFieldsNameOfIssue) {
name = jsonFieldsNameOfIssue[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 *Issue) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Issue) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *IssueComment) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *IssueComment) encodeFields(e *jx.Encoder) {
{
e.FieldStart("id")
e.Int64(s.ID)
}
{
e.FieldStart("body")
e.Str(s.Body)
}
{
e.FieldStart("html_url")
json.EncodeURI(e, s.HTMLURL)
}
{
if s.User.Set {
e.FieldStart("user")
s.User.Encode(e)
}
}
{
if s.CreatedAt.Set {
e.FieldStart("created_at")
s.CreatedAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.UpdatedAt.Set {
e.FieldStart("updated_at")
s.UpdatedAt.Encode(e, json.EncodeDateTime)
}
}
}
var jsonFieldsNameOfIssueComment = [6]string{
0: "id",
1: "body",
2: "html_url",
3: "user",
4: "created_at",
5: "updated_at",
}
// Decode decodes IssueComment from json.
func (s *IssueComment) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode IssueComment 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.Int64()
s.ID = int64(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"id\"")
}
case "body":
requiredBitSet[0] |= 1 << 1
if err := func() error {
v, err := d.Str()
s.Body = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"body\"")
}
case "html_url":
requiredBitSet[0] |= 1 << 2
if err := func() error {
v, err := json.DecodeURI(d)
s.HTMLURL = v
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"html_url\"")
}
case "user":
if err := func() error {
s.User.Reset()
if err := s.User.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"user\"")
}
case "created_at":
if err := func() error {
s.CreatedAt.Reset()
if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"created_at\"")
}
case "updated_at":
if err := func() error {
s.UpdatedAt.Reset()
if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"updated_at\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode IssueComment")
}
// 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(jsonFieldsNameOfIssueComment) {
name = jsonFieldsNameOfIssueComment[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 *IssueComment) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *IssueComment) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *IssueUser) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *IssueUser) encodeFields(e *jx.Encoder) {
{
e.FieldStart("login")
e.Str(s.Login)
}
{
e.FieldStart("id")
e.Int64(s.ID)
}
}
var jsonFieldsNameOfIssueUser = [2]string{
0: "login",
1: "id",
}
// Decode decodes IssueUser from json.
func (s *IssueUser) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode IssueUser to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "login":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Str()
s.Login = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"login\"")
}
case "id":
requiredBitSet[0] |= 1 << 1
if err := func() error {
v, err := d.Int64()
s.ID = int64(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"id\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode IssueUser")
}
// 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(jsonFieldsNameOfIssueUser) {
name = jsonFieldsNameOfIssueUser[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 *IssueUser) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *IssueUser) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *Label) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *Label) encodeFields(e *jx.Encoder) {
{
if s.Name.Set {
e.FieldStart("name")
s.Name.Encode(e)
}
}
{
if s.Color.Set {
e.FieldStart("color")
s.Color.Encode(e)
}
}
}
var jsonFieldsNameOfLabel = [2]string{
0: "name",
1: "color",
}
// Decode decodes Label from json.
func (s *Label) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode Label to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "name":
if err := func() error {
s.Name.Reset()
if err := s.Name.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"name\"")
}
case "color":
if err := func() error {
s.Color.Reset()
if err := s.Color.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"color\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode Label")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *Label) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Label) 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 CommitCommit as json.
func (o OptCommitCommit) Encode(e *jx.Encoder) {
if !o.Set {
return
}
o.Value.Encode(e)
}
// Decode decodes CommitCommit from json.
func (o *OptCommitCommit) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptCommitCommit to nil")
}
o.Set = true
if err := o.Value.Decode(d); err != nil {
return err
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptCommitCommit) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptCommitCommit) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode encodes CommitCommitAuthor as json.
func (o OptCommitCommitAuthor) Encode(e *jx.Encoder) {
if !o.Set {
return
}
o.Value.Encode(e)
}
// Decode decodes CommitCommitAuthor from json.
func (o *OptCommitCommitAuthor) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptCommitCommitAuthor to nil")
}
o.Set = true
if err := o.Value.Decode(d); err != nil {
return err
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptCommitCommitAuthor) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptCommitCommitAuthor) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode encodes time.Time as json.
func (o OptDateTime) Encode(e *jx.Encoder, format func(*jx.Encoder, time.Time)) {
if !o.Set {
return
}
format(e, o.Value)
}
// Decode decodes time.Time from json.
func (o *OptDateTime) Decode(d *jx.Decoder, format func(*jx.Decoder) (time.Time, error)) error {
if o == nil {
return errors.New("invalid: unable to decode OptDateTime to nil")
}
o.Set = true
v, err := format(d)
if err != nil {
return err
}
o.Value = v
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptDateTime) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e, json.EncodeDateTime)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptDateTime) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d, json.DecodeDateTime)
}
// Encode encodes int as json.
func (o OptInt) Encode(e *jx.Encoder) {
if !o.Set {
return
}
e.Int(int(o.Value))
}
// Decode decodes int from json.
func (o *OptInt) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptInt to nil")
}
o.Set = true
v, err := d.Int()
if err != nil {
return err
}
o.Value = int(v)
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptInt) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptInt) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode encodes IssueUser as json.
func (o OptIssueUser) Encode(e *jx.Encoder) {
if !o.Set {
return
}
o.Value.Encode(e)
}
// Decode decodes IssueUser from json.
func (o *OptIssueUser) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptIssueUser to nil")
}
o.Set = true
if err := o.Value.Decode(d); err != nil {
return err
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptIssueUser) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptIssueUser) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode encodes time.Time as json.
func (o OptNilDateTime) Encode(e *jx.Encoder, format func(*jx.Encoder, time.Time)) {
if !o.Set {
return
}
if o.Null {
e.Null()
return
}
format(e, o.Value)
}
// Decode decodes time.Time from json.
func (o *OptNilDateTime) Decode(d *jx.Decoder, format func(*jx.Decoder) (time.Time, error)) error {
if o == nil {
return errors.New("invalid: unable to decode OptNilDateTime to nil")
}
if d.Next() == jx.Null {
if err := d.Null(); err != nil {
return err
}
var v time.Time
o.Value = v
o.Set = true
o.Null = true
return nil
}
o.Set = true
o.Null = false
v, err := format(d)
if err != nil {
return err
}
o.Value = v
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptNilDateTime) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e, json.EncodeDateTime)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptNilDateTime) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d, json.DecodeDateTime)
}
// 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 PublicEventRepo as json.
func (o OptPublicEventRepo) Encode(e *jx.Encoder) {
if !o.Set {
return
}
o.Value.Encode(e)
}
// Decode decodes PublicEventRepo from json.
func (o *OptPublicEventRepo) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptPublicEventRepo to nil")
}
o.Set = true
if err := o.Value.Decode(d); err != nil {
return err
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptPublicEventRepo) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptPublicEventRepo) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode encodes PullRequestBase as json.
func (o OptPullRequestBase) Encode(e *jx.Encoder) {
if !o.Set {
return
}
o.Value.Encode(e)
}
// Decode decodes PullRequestBase from json.
func (o *OptPullRequestBase) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptPullRequestBase to nil")
}
o.Set = true
if err := o.Value.Decode(d); err != nil {
return err
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptPullRequestBase) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptPullRequestBase) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode encodes PullRequestHead as json.
func (o OptPullRequestHead) Encode(e *jx.Encoder) {
if !o.Set {
return
}
o.Value.Encode(e)
}
// Decode decodes PullRequestHead from json.
func (o *OptPullRequestHead) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptPullRequestHead to nil")
}
o.Set = true
if err := o.Value.Decode(d); err != nil {
return err
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptPullRequestHead) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptPullRequestHead) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode encodes Repository as json.
func (o OptRepository) Encode(e *jx.Encoder) {
if !o.Set {
return
}
o.Value.Encode(e)
}
// Decode decodes Repository from json.
func (o *OptRepository) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptRepository to nil")
}
o.Set = true
if err := o.Value.Decode(d); err != nil {
return err
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptRepository) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptRepository) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode encodes RepositoryOwner as json.
func (o OptRepositoryOwner) Encode(e *jx.Encoder) {
if !o.Set {
return
}
o.Value.Encode(e)
}
// Decode decodes RepositoryOwner from json.
func (o *OptRepositoryOwner) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptRepositoryOwner to nil")
}
o.Set = true
if err := o.Value.Decode(d); err != nil {
return err
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptRepositoryOwner) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptRepositoryOwner) 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 encodes url.URL as json.
func (o OptURI) Encode(e *jx.Encoder) {
if !o.Set {
return
}
json.EncodeURI(e, o.Value)
}
// Decode decodes url.URL from json.
func (o *OptURI) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptURI to nil")
}
o.Set = true
v, err := json.DecodeURI(d)
if err != nil {
return err
}
o.Value = v
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptURI) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptURI) 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("login")
e.Str(s.Login)
}
{
e.FieldStart("id")
e.Int64(s.ID)
}
{
if s.Description.Set {
e.FieldStart("description")
s.Description.Encode(e)
}
}
{
if s.AvatarURL.Set {
e.FieldStart("avatar_url")
s.AvatarURL.Encode(e)
}
}
}
var jsonFieldsNameOfOrganization = [4]string{
0: "login",
1: "id",
2: "description",
3: "avatar_url",
}
// 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 "login":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Str()
s.Login = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"login\"")
}
case "id":
requiredBitSet[0] |= 1 << 1
if err := func() error {
v, err := d.Int64()
s.ID = int64(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"id\"")
}
case "description":
if err := func() error {
s.Description.Reset()
if err := s.Description.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"description\"")
}
case "avatar_url":
if err := func() error {
s.AvatarURL.Reset()
if err := s.AvatarURL.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"avatar_url\"")
}
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{
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(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 *PublicEvent) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *PublicEvent) encodeFields(e *jx.Encoder) {
{
e.FieldStart("id")
e.Str(s.ID)
}
{
e.FieldStart("type")
e.Str(s.Type)
}
{
if s.Repo.Set {
e.FieldStart("repo")
s.Repo.Encode(e)
}
}
{
if s.CreatedAt.Set {
e.FieldStart("created_at")
s.CreatedAt.Encode(e, json.EncodeDateTime)
}
}
}
var jsonFieldsNameOfPublicEvent = [4]string{
0: "id",
1: "type",
2: "repo",
3: "created_at",
}
// Decode decodes PublicEvent from json.
func (s *PublicEvent) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode PublicEvent 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 "type":
requiredBitSet[0] |= 1 << 1
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 "repo":
if err := func() error {
s.Repo.Reset()
if err := s.Repo.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"repo\"")
}
case "created_at":
if err := func() error {
s.CreatedAt.Reset()
if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"created_at\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode PublicEvent")
}
// 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(jsonFieldsNameOfPublicEvent) {
name = jsonFieldsNameOfPublicEvent[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 *PublicEvent) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PublicEvent) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *PublicEventRepo) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *PublicEventRepo) encodeFields(e *jx.Encoder) {
{
if s.Name.Set {
e.FieldStart("name")
s.Name.Encode(e)
}
}
}
var jsonFieldsNameOfPublicEventRepo = [1]string{
0: "name",
}
// Decode decodes PublicEventRepo from json.
func (s *PublicEventRepo) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode PublicEventRepo to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "name":
if err := func() error {
s.Name.Reset()
if err := s.Name.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"name\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode PublicEventRepo")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *PublicEventRepo) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PublicEventRepo) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *PullRequest) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *PullRequest) encodeFields(e *jx.Encoder) {
{
e.FieldStart("id")
e.Int64(s.ID)
}
{
e.FieldStart("number")
e.Int(s.Number)
}
{
e.FieldStart("title")
e.Str(s.Title)
}
{
e.FieldStart("state")
e.Str(s.State)
}
{
if s.Body.Set {
e.FieldStart("body")
s.Body.Encode(e)
}
}
{
e.FieldStart("html_url")
json.EncodeURI(e, s.HTMLURL)
}
{
if s.User.Set {
e.FieldStart("user")
s.User.Encode(e)
}
}
{
if s.Draft.Set {
e.FieldStart("draft")
s.Draft.Encode(e)
}
}
{
if s.Merged.Set {
e.FieldStart("merged")
s.Merged.Encode(e)
}
}
{
if s.Head.Set {
e.FieldStart("head")
s.Head.Encode(e)
}
}
{
if s.Base.Set {
e.FieldStart("base")
s.Base.Encode(e)
}
}
{
if s.CreatedAt.Set {
e.FieldStart("created_at")
s.CreatedAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.UpdatedAt.Set {
e.FieldStart("updated_at")
s.UpdatedAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.MergedAt.Set {
e.FieldStart("merged_at")
s.MergedAt.Encode(e, json.EncodeDateTime)
}
}
}
var jsonFieldsNameOfPullRequest = [14]string{
0: "id",
1: "number",
2: "title",
3: "state",
4: "body",
5: "html_url",
6: "user",
7: "draft",
8: "merged",
9: "head",
10: "base",
11: "created_at",
12: "updated_at",
13: "merged_at",
}
// Decode decodes PullRequest from json.
func (s *PullRequest) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode PullRequest 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.Int64()
s.ID = int64(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"id\"")
}
case "number":
requiredBitSet[0] |= 1 << 1
if err := func() error {
v, err := d.Int()
s.Number = int(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"number\"")
}
case "title":
requiredBitSet[0] |= 1 << 2
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 "state":
requiredBitSet[0] |= 1 << 3
if err := func() error {
v, err := d.Str()
s.State = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"state\"")
}
case "body":
if err := func() error {
s.Body.Reset()
if err := s.Body.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"body\"")
}
case "html_url":
requiredBitSet[0] |= 1 << 5
if err := func() error {
v, err := json.DecodeURI(d)
s.HTMLURL = v
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"html_url\"")
}
case "user":
if err := func() error {
s.User.Reset()
if err := s.User.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"user\"")
}
case "draft":
if err := func() error {
s.Draft.Reset()
if err := s.Draft.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"draft\"")
}
case "merged":
if err := func() error {
s.Merged.Reset()
if err := s.Merged.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"merged\"")
}
case "head":
if err := func() error {
s.Head.Reset()
if err := s.Head.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"head\"")
}
case "base":
if err := func() error {
s.Base.Reset()
if err := s.Base.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"base\"")
}
case "created_at":
if err := func() error {
s.CreatedAt.Reset()
if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"created_at\"")
}
case "updated_at":
if err := func() error {
s.UpdatedAt.Reset()
if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"updated_at\"")
}
case "merged_at":
if err := func() error {
s.MergedAt.Reset()
if err := s.MergedAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"merged_at\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode PullRequest")
}
// Validate required fields.
var failures []validate.FieldError
for i, mask := range [2]uint8{
0b00101111,
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(jsonFieldsNameOfPullRequest) {
name = jsonFieldsNameOfPullRequest[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 *PullRequest) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PullRequest) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *PullRequestBase) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *PullRequestBase) encodeFields(e *jx.Encoder) {
{
if s.Ref.Set {
e.FieldStart("ref")
s.Ref.Encode(e)
}
}
{
if s.Sha.Set {
e.FieldStart("sha")
s.Sha.Encode(e)
}
}
}
var jsonFieldsNameOfPullRequestBase = [2]string{
0: "ref",
1: "sha",
}
// Decode decodes PullRequestBase from json.
func (s *PullRequestBase) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode PullRequestBase to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "ref":
if err := func() error {
s.Ref.Reset()
if err := s.Ref.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ref\"")
}
case "sha":
if err := func() error {
s.Sha.Reset()
if err := s.Sha.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"sha\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode PullRequestBase")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *PullRequestBase) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PullRequestBase) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *PullRequestFile) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *PullRequestFile) encodeFields(e *jx.Encoder) {
{
if s.Sha.Set {
e.FieldStart("sha")
s.Sha.Encode(e)
}
}
{
e.FieldStart("filename")
e.Str(s.Filename)
}
{
e.FieldStart("status")
e.Str(s.Status)
}
{
if s.Additions.Set {
e.FieldStart("additions")
s.Additions.Encode(e)
}
}
{
if s.Deletions.Set {
e.FieldStart("deletions")
s.Deletions.Encode(e)
}
}
{
if s.Changes.Set {
e.FieldStart("changes")
s.Changes.Encode(e)
}
}
{
if s.Patch.Set {
e.FieldStart("patch")
s.Patch.Encode(e)
}
}
}
var jsonFieldsNameOfPullRequestFile = [7]string{
0: "sha",
1: "filename",
2: "status",
3: "additions",
4: "deletions",
5: "changes",
6: "patch",
}
// Decode decodes PullRequestFile from json.
func (s *PullRequestFile) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode PullRequestFile to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "sha":
if err := func() error {
s.Sha.Reset()
if err := s.Sha.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"sha\"")
}
case "filename":
requiredBitSet[0] |= 1 << 1
if err := func() error {
v, err := d.Str()
s.Filename = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"filename\"")
}
case "status":
requiredBitSet[0] |= 1 << 2
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 "additions":
if err := func() error {
s.Additions.Reset()
if err := s.Additions.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"additions\"")
}
case "deletions":
if err := func() error {
s.Deletions.Reset()
if err := s.Deletions.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"deletions\"")
}
case "changes":
if err := func() error {
s.Changes.Reset()
if err := s.Changes.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"changes\"")
}
case "patch":
if err := func() error {
s.Patch.Reset()
if err := s.Patch.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"patch\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode PullRequestFile")
}
// 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(jsonFieldsNameOfPullRequestFile) {
name = jsonFieldsNameOfPullRequestFile[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 *PullRequestFile) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PullRequestFile) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *PullRequestHead) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *PullRequestHead) encodeFields(e *jx.Encoder) {
{
if s.Ref.Set {
e.FieldStart("ref")
s.Ref.Encode(e)
}
}
{
if s.Sha.Set {
e.FieldStart("sha")
s.Sha.Encode(e)
}
}
}
var jsonFieldsNameOfPullRequestHead = [2]string{
0: "ref",
1: "sha",
}
// Decode decodes PullRequestHead from json.
func (s *PullRequestHead) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode PullRequestHead to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "ref":
if err := func() error {
s.Ref.Reset()
if err := s.Ref.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"ref\"")
}
case "sha":
if err := func() error {
s.Sha.Reset()
if err := s.Sha.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"sha\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode PullRequestHead")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *PullRequestHead) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *PullRequestHead) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *Repository) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *Repository) encodeFields(e *jx.Encoder) {
{
e.FieldStart("id")
e.Int64(s.ID)
}
{
e.FieldStart("name")
e.Str(s.Name)
}
{
e.FieldStart("full_name")
e.Str(s.FullName)
}
{
if s.Description.Set {
e.FieldStart("description")
s.Description.Encode(e)
}
}
{
e.FieldStart("private")
e.Bool(s.Private)
}
{
e.FieldStart("html_url")
json.EncodeURI(e, s.HTMLURL)
}
{
e.FieldStart("owner")
s.Owner.Encode(e)
}
{
if s.Fork.Set {
e.FieldStart("fork")
s.Fork.Encode(e)
}
}
{
if s.Language.Set {
e.FieldStart("language")
s.Language.Encode(e)
}
}
{
if s.StargazersCount.Set {
e.FieldStart("stargazers_count")
s.StargazersCount.Encode(e)
}
}
{
if s.WatchersCount.Set {
e.FieldStart("watchers_count")
s.WatchersCount.Encode(e)
}
}
{
if s.ForksCount.Set {
e.FieldStart("forks_count")
s.ForksCount.Encode(e)
}
}
{
if s.OpenIssuesCount.Set {
e.FieldStart("open_issues_count")
s.OpenIssuesCount.Encode(e)
}
}
{
if s.DefaultBranch.Set {
e.FieldStart("default_branch")
s.DefaultBranch.Encode(e)
}
}
{
if s.Topics != nil {
e.FieldStart("topics")
e.ArrStart()
for _, elem := range s.Topics {
e.Str(elem)
}
e.ArrEnd()
}
}
{
if s.Archived.Set {
e.FieldStart("archived")
s.Archived.Encode(e)
}
}
{
if s.Disabled.Set {
e.FieldStart("disabled")
s.Disabled.Encode(e)
}
}
{
if s.Visibility.Set {
e.FieldStart("visibility")
s.Visibility.Encode(e)
}
}
{
if s.PushedAt.Set {
e.FieldStart("pushed_at")
s.PushedAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.CreatedAt.Set {
e.FieldStart("created_at")
s.CreatedAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.UpdatedAt.Set {
e.FieldStart("updated_at")
s.UpdatedAt.Encode(e, json.EncodeDateTime)
}
}
}
var jsonFieldsNameOfRepository = [21]string{
0: "id",
1: "name",
2: "full_name",
3: "description",
4: "private",
5: "html_url",
6: "owner",
7: "fork",
8: "language",
9: "stargazers_count",
10: "watchers_count",
11: "forks_count",
12: "open_issues_count",
13: "default_branch",
14: "topics",
15: "archived",
16: "disabled",
17: "visibility",
18: "pushed_at",
19: "created_at",
20: "updated_at",
}
// Decode decodes Repository from json.
func (s *Repository) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode Repository 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.Int64()
s.ID = int64(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 "full_name":
requiredBitSet[0] |= 1 << 2
if err := func() error {
v, err := d.Str()
s.FullName = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"full_name\"")
}
case "description":
if err := func() error {
s.Description.Reset()
if err := s.Description.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"description\"")
}
case "private":
requiredBitSet[0] |= 1 << 4
if err := func() error {
v, err := d.Bool()
s.Private = bool(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"private\"")
}
case "html_url":
requiredBitSet[0] |= 1 << 5
if err := func() error {
v, err := json.DecodeURI(d)
s.HTMLURL = v
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"html_url\"")
}
case "owner":
requiredBitSet[0] |= 1 << 6
if err := func() error {
if err := s.Owner.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"owner\"")
}
case "fork":
if err := func() error {
s.Fork.Reset()
if err := s.Fork.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"fork\"")
}
case "language":
if err := func() error {
s.Language.Reset()
if err := s.Language.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"language\"")
}
case "stargazers_count":
if err := func() error {
s.StargazersCount.Reset()
if err := s.StargazersCount.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"stargazers_count\"")
}
case "watchers_count":
if err := func() error {
s.WatchersCount.Reset()
if err := s.WatchersCount.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"watchers_count\"")
}
case "forks_count":
if err := func() error {
s.ForksCount.Reset()
if err := s.ForksCount.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"forks_count\"")
}
case "open_issues_count":
if err := func() error {
s.OpenIssuesCount.Reset()
if err := s.OpenIssuesCount.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"open_issues_count\"")
}
case "default_branch":
if err := func() error {
s.DefaultBranch.Reset()
if err := s.DefaultBranch.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"default_branch\"")
}
case "topics":
if err := func() error {
s.Topics = 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.Topics = append(s.Topics, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"topics\"")
}
case "archived":
if err := func() error {
s.Archived.Reset()
if err := s.Archived.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"archived\"")
}
case "disabled":
if err := func() error {
s.Disabled.Reset()
if err := s.Disabled.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"disabled\"")
}
case "visibility":
if err := func() error {
s.Visibility.Reset()
if err := s.Visibility.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"visibility\"")
}
case "pushed_at":
if err := func() error {
s.PushedAt.Reset()
if err := s.PushedAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"pushed_at\"")
}
case "created_at":
if err := func() error {
s.CreatedAt.Reset()
if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"created_at\"")
}
case "updated_at":
if err := func() error {
s.UpdatedAt.Reset()
if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"updated_at\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode Repository")
}
// Validate required fields.
var failures []validate.FieldError
for i, mask := range [3]uint8{
0b01110111,
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(jsonFieldsNameOfRepository) {
name = jsonFieldsNameOfRepository[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 *Repository) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Repository) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *RepositoryOwner) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *RepositoryOwner) encodeFields(e *jx.Encoder) {
{
e.FieldStart("login")
e.Str(s.Login)
}
{
e.FieldStart("id")
e.Int64(s.ID)
}
{
if s.AvatarURL.Set {
e.FieldStart("avatar_url")
s.AvatarURL.Encode(e)
}
}
{
if s.HTMLURL.Set {
e.FieldStart("html_url")
s.HTMLURL.Encode(e)
}
}
{
if s.Type.Set {
e.FieldStart("type")
s.Type.Encode(e)
}
}
}
var jsonFieldsNameOfRepositoryOwner = [5]string{
0: "login",
1: "id",
2: "avatar_url",
3: "html_url",
4: "type",
}
// Decode decodes RepositoryOwner from json.
func (s *RepositoryOwner) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode RepositoryOwner to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "login":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Str()
s.Login = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"login\"")
}
case "id":
requiredBitSet[0] |= 1 << 1
if err := func() error {
v, err := d.Int64()
s.ID = int64(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"id\"")
}
case "avatar_url":
if err := func() error {
s.AvatarURL.Reset()
if err := s.AvatarURL.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"avatar_url\"")
}
case "html_url":
if err := func() error {
s.HTMLURL.Reset()
if err := s.HTMLURL.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"html_url\"")
}
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 RepositoryOwner")
}
// 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(jsonFieldsNameOfRepositoryOwner) {
name = jsonFieldsNameOfRepositoryOwner[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 *RepositoryOwner) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *RepositoryOwner) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *SearchResultCode) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *SearchResultCode) encodeFields(e *jx.Encoder) {
{
e.FieldStart("total_count")
e.Int(s.TotalCount)
}
{
if s.IncompleteResults.Set {
e.FieldStart("incomplete_results")
s.IncompleteResults.Encode(e)
}
}
{
e.FieldStart("items")
e.ArrStart()
for _, elem := range s.Items {
elem.Encode(e)
}
e.ArrEnd()
}
}
var jsonFieldsNameOfSearchResultCode = [3]string{
0: "total_count",
1: "incomplete_results",
2: "items",
}
// Decode decodes SearchResultCode from json.
func (s *SearchResultCode) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode SearchResultCode to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "total_count":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Int()
s.TotalCount = int(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"total_count\"")
}
case "incomplete_results":
if err := func() error {
s.IncompleteResults.Reset()
if err := s.IncompleteResults.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"incomplete_results\"")
}
case "items":
requiredBitSet[0] |= 1 << 2
if err := func() error {
s.Items = make([]SearchResultCodeItemsItem, 0)
if err := d.Arr(func(d *jx.Decoder) error {
var elem SearchResultCodeItemsItem
if err := elem.Decode(d); err != nil {
return err
}
s.Items = append(s.Items, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"items\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode SearchResultCode")
}
// Validate required fields.
var failures []validate.FieldError
for i, mask := range [1]uint8{
0b00000101,
} {
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(jsonFieldsNameOfSearchResultCode) {
name = jsonFieldsNameOfSearchResultCode[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 *SearchResultCode) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SearchResultCode) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *SearchResultCodeItemsItem) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *SearchResultCodeItemsItem) encodeFields(e *jx.Encoder) {
{
if s.Name.Set {
e.FieldStart("name")
s.Name.Encode(e)
}
}
{
if s.Path.Set {
e.FieldStart("path")
s.Path.Encode(e)
}
}
{
if s.Sha.Set {
e.FieldStart("sha")
s.Sha.Encode(e)
}
}
{
if s.HTMLURL.Set {
e.FieldStart("html_url")
s.HTMLURL.Encode(e)
}
}
{
if s.Repository.Set {
e.FieldStart("repository")
s.Repository.Encode(e)
}
}
}
var jsonFieldsNameOfSearchResultCodeItemsItem = [5]string{
0: "name",
1: "path",
2: "sha",
3: "html_url",
4: "repository",
}
// Decode decodes SearchResultCodeItemsItem from json.
func (s *SearchResultCodeItemsItem) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode SearchResultCodeItemsItem to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "name":
if err := func() error {
s.Name.Reset()
if err := s.Name.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"name\"")
}
case "path":
if err := func() error {
s.Path.Reset()
if err := s.Path.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"path\"")
}
case "sha":
if err := func() error {
s.Sha.Reset()
if err := s.Sha.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"sha\"")
}
case "html_url":
if err := func() error {
s.HTMLURL.Reset()
if err := s.HTMLURL.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"html_url\"")
}
case "repository":
if err := func() error {
s.Repository.Reset()
if err := s.Repository.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"repository\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode SearchResultCodeItemsItem")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *SearchResultCodeItemsItem) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SearchResultCodeItemsItem) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *SearchResultIssues) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *SearchResultIssues) encodeFields(e *jx.Encoder) {
{
e.FieldStart("total_count")
e.Int(s.TotalCount)
}
{
if s.IncompleteResults.Set {
e.FieldStart("incomplete_results")
s.IncompleteResults.Encode(e)
}
}
{
e.FieldStart("items")
e.ArrStart()
for _, elem := range s.Items {
elem.Encode(e)
}
e.ArrEnd()
}
}
var jsonFieldsNameOfSearchResultIssues = [3]string{
0: "total_count",
1: "incomplete_results",
2: "items",
}
// Decode decodes SearchResultIssues from json.
func (s *SearchResultIssues) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode SearchResultIssues to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "total_count":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Int()
s.TotalCount = int(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"total_count\"")
}
case "incomplete_results":
if err := func() error {
s.IncompleteResults.Reset()
if err := s.IncompleteResults.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"incomplete_results\"")
}
case "items":
requiredBitSet[0] |= 1 << 2
if err := func() error {
s.Items = make([]Issue, 0)
if err := d.Arr(func(d *jx.Decoder) error {
var elem Issue
if err := elem.Decode(d); err != nil {
return err
}
s.Items = append(s.Items, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"items\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode SearchResultIssues")
}
// Validate required fields.
var failures []validate.FieldError
for i, mask := range [1]uint8{
0b00000101,
} {
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(jsonFieldsNameOfSearchResultIssues) {
name = jsonFieldsNameOfSearchResultIssues[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 *SearchResultIssues) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SearchResultIssues) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *SearchResultRepositories) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *SearchResultRepositories) encodeFields(e *jx.Encoder) {
{
e.FieldStart("total_count")
e.Int(s.TotalCount)
}
{
if s.IncompleteResults.Set {
e.FieldStart("incomplete_results")
s.IncompleteResults.Encode(e)
}
}
{
e.FieldStart("items")
e.ArrStart()
for _, elem := range s.Items {
elem.Encode(e)
}
e.ArrEnd()
}
}
var jsonFieldsNameOfSearchResultRepositories = [3]string{
0: "total_count",
1: "incomplete_results",
2: "items",
}
// Decode decodes SearchResultRepositories from json.
func (s *SearchResultRepositories) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode SearchResultRepositories to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "total_count":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Int()
s.TotalCount = int(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"total_count\"")
}
case "incomplete_results":
if err := func() error {
s.IncompleteResults.Reset()
if err := s.IncompleteResults.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"incomplete_results\"")
}
case "items":
requiredBitSet[0] |= 1 << 2
if err := func() error {
s.Items = make([]Repository, 0)
if err := d.Arr(func(d *jx.Decoder) error {
var elem Repository
if err := elem.Decode(d); err != nil {
return err
}
s.Items = append(s.Items, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"items\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode SearchResultRepositories")
}
// Validate required fields.
var failures []validate.FieldError
for i, mask := range [1]uint8{
0b00000101,
} {
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(jsonFieldsNameOfSearchResultRepositories) {
name = jsonFieldsNameOfSearchResultRepositories[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 *SearchResultRepositories) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SearchResultRepositories) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *SimpleUser) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *SimpleUser) encodeFields(e *jx.Encoder) {
{
e.FieldStart("id")
e.Int64(s.ID)
}
{
e.FieldStart("login")
e.Str(s.Login)
}
{
if s.Name.Set {
e.FieldStart("name")
s.Name.Encode(e)
}
}
{
if s.Email.Set {
e.FieldStart("email")
s.Email.Encode(e)
}
}
{
if s.AvatarURL.Set {
e.FieldStart("avatar_url")
s.AvatarURL.Encode(e)
}
}
{
if s.HTMLURL.Set {
e.FieldStart("html_url")
s.HTMLURL.Encode(e)
}
}
{
if s.Type.Set {
e.FieldStart("type")
s.Type.Encode(e)
}
}
{
if s.Bio.Set {
e.FieldStart("bio")
s.Bio.Encode(e)
}
}
{
if s.PublicRepos.Set {
e.FieldStart("public_repos")
s.PublicRepos.Encode(e)
}
}
{
if s.PublicGists.Set {
e.FieldStart("public_gists")
s.PublicGists.Encode(e)
}
}
{
if s.Followers.Set {
e.FieldStart("followers")
s.Followers.Encode(e)
}
}
{
if s.Following.Set {
e.FieldStart("following")
s.Following.Encode(e)
}
}
{
if s.CreatedAt.Set {
e.FieldStart("created_at")
s.CreatedAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.UpdatedAt.Set {
e.FieldStart("updated_at")
s.UpdatedAt.Encode(e, json.EncodeDateTime)
}
}
}
var jsonFieldsNameOfSimpleUser = [14]string{
0: "id",
1: "login",
2: "name",
3: "email",
4: "avatar_url",
5: "html_url",
6: "type",
7: "bio",
8: "public_repos",
9: "public_gists",
10: "followers",
11: "following",
12: "created_at",
13: "updated_at",
}
// Decode decodes SimpleUser from json.
func (s *SimpleUser) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode SimpleUser 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.Int64()
s.ID = int64(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"id\"")
}
case "login":
requiredBitSet[0] |= 1 << 1
if err := func() error {
v, err := d.Str()
s.Login = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"login\"")
}
case "name":
if err := func() error {
s.Name.Reset()
if err := s.Name.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"name\"")
}
case "email":
if err := func() error {
s.Email.Reset()
if err := s.Email.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"email\"")
}
case "avatar_url":
if err := func() error {
s.AvatarURL.Reset()
if err := s.AvatarURL.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"avatar_url\"")
}
case "html_url":
if err := func() error {
s.HTMLURL.Reset()
if err := s.HTMLURL.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"html_url\"")
}
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\"")
}
case "bio":
if err := func() error {
s.Bio.Reset()
if err := s.Bio.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"bio\"")
}
case "public_repos":
if err := func() error {
s.PublicRepos.Reset()
if err := s.PublicRepos.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"public_repos\"")
}
case "public_gists":
if err := func() error {
s.PublicGists.Reset()
if err := s.PublicGists.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"public_gists\"")
}
case "followers":
if err := func() error {
s.Followers.Reset()
if err := s.Followers.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"followers\"")
}
case "following":
if err := func() error {
s.Following.Reset()
if err := s.Following.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"following\"")
}
case "created_at":
if err := func() error {
s.CreatedAt.Reset()
if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"created_at\"")
}
case "updated_at":
if err := func() error {
s.UpdatedAt.Reset()
if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"updated_at\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode SimpleUser")
}
// Validate required fields.
var failures []validate.FieldError
for i, mask := range [2]uint8{
0b00000011,
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(jsonFieldsNameOfSimpleUser) {
name = jsonFieldsNameOfSimpleUser[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 *SimpleUser) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SimpleUser) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *UpdateIssueRequest) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *UpdateIssueRequest) encodeFields(e *jx.Encoder) {
{
if s.Title.Set {
e.FieldStart("title")
s.Title.Encode(e)
}
}
{
if s.Body.Set {
e.FieldStart("body")
s.Body.Encode(e)
}
}
{
if s.State.Set {
e.FieldStart("state")
s.State.Encode(e)
}
}
{
if s.Labels != nil {
e.FieldStart("labels")
e.ArrStart()
for _, elem := range s.Labels {
e.Str(elem)
}
e.ArrEnd()
}
}
{
if s.Assignees != nil {
e.FieldStart("assignees")
e.ArrStart()
for _, elem := range s.Assignees {
e.Str(elem)
}
e.ArrEnd()
}
}
}
var jsonFieldsNameOfUpdateIssueRequest = [5]string{
0: "title",
1: "body",
2: "state",
3: "labels",
4: "assignees",
}
// Decode decodes UpdateIssueRequest from json.
func (s *UpdateIssueRequest) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode UpdateIssueRequest to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "title":
if err := func() error {
s.Title.Reset()
if err := s.Title.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"title\"")
}
case "body":
if err := func() error {
s.Body.Reset()
if err := s.Body.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"body\"")
}
case "state":
if err := func() error {
s.State.Reset()
if err := s.State.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"state\"")
}
case "labels":
if err := func() error {
s.Labels = 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.Labels = append(s.Labels, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"labels\"")
}
case "assignees":
if err := func() error {
s.Assignees = 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.Assignees = append(s.Assignees, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"assignees\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode UpdateIssueRequest")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *UpdateIssueRequest) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *UpdateIssueRequest) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *Workflow) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *Workflow) encodeFields(e *jx.Encoder) {
{
e.FieldStart("id")
e.Int64(s.ID)
}
{
e.FieldStart("name")
e.Str(s.Name)
}
{
if s.Path.Set {
e.FieldStart("path")
s.Path.Encode(e)
}
}
{
e.FieldStart("state")
e.Str(s.State)
}
{
if s.HTMLURL.Set {
e.FieldStart("html_url")
s.HTMLURL.Encode(e)
}
}
{
if s.CreatedAt.Set {
e.FieldStart("created_at")
s.CreatedAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.UpdatedAt.Set {
e.FieldStart("updated_at")
s.UpdatedAt.Encode(e, json.EncodeDateTime)
}
}
}
var jsonFieldsNameOfWorkflow = [7]string{
0: "id",
1: "name",
2: "path",
3: "state",
4: "html_url",
5: "created_at",
6: "updated_at",
}
// Decode decodes Workflow from json.
func (s *Workflow) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode Workflow 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.Int64()
s.ID = int64(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 "path":
if err := func() error {
s.Path.Reset()
if err := s.Path.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"path\"")
}
case "state":
requiredBitSet[0] |= 1 << 3
if err := func() error {
v, err := d.Str()
s.State = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"state\"")
}
case "html_url":
if err := func() error {
s.HTMLURL.Reset()
if err := s.HTMLURL.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"html_url\"")
}
case "created_at":
if err := func() error {
s.CreatedAt.Reset()
if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"created_at\"")
}
case "updated_at":
if err := func() error {
s.UpdatedAt.Reset()
if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"updated_at\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode Workflow")
}
// Validate required fields.
var failures []validate.FieldError
for i, mask := range [1]uint8{
0b00001011,
} {
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(jsonFieldsNameOfWorkflow) {
name = jsonFieldsNameOfWorkflow[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 *Workflow) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Workflow) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *WorkflowRun) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *WorkflowRun) encodeFields(e *jx.Encoder) {
{
e.FieldStart("id")
e.Int64(s.ID)
}
{
e.FieldStart("name")
e.Str(s.Name)
}
{
if s.HeadBranch.Set {
e.FieldStart("head_branch")
s.HeadBranch.Encode(e)
}
}
{
if s.HeadSha.Set {
e.FieldStart("head_sha")
s.HeadSha.Encode(e)
}
}
{
e.FieldStart("status")
e.Str(s.Status)
}
{
if s.Conclusion.Set {
e.FieldStart("conclusion")
s.Conclusion.Encode(e)
}
}
{
e.FieldStart("html_url")
json.EncodeURI(e, s.HTMLURL)
}
{
if s.CreatedAt.Set {
e.FieldStart("created_at")
s.CreatedAt.Encode(e, json.EncodeDateTime)
}
}
{
if s.UpdatedAt.Set {
e.FieldStart("updated_at")
s.UpdatedAt.Encode(e, json.EncodeDateTime)
}
}
}
var jsonFieldsNameOfWorkflowRun = [9]string{
0: "id",
1: "name",
2: "head_branch",
3: "head_sha",
4: "status",
5: "conclusion",
6: "html_url",
7: "created_at",
8: "updated_at",
}
// Decode decodes WorkflowRun from json.
func (s *WorkflowRun) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode WorkflowRun 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.Int64()
s.ID = int64(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 "head_branch":
if err := func() error {
s.HeadBranch.Reset()
if err := s.HeadBranch.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"head_branch\"")
}
case "head_sha":
if err := func() error {
s.HeadSha.Reset()
if err := s.HeadSha.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"head_sha\"")
}
case "status":
requiredBitSet[0] |= 1 << 4
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 "conclusion":
if err := func() error {
s.Conclusion.Reset()
if err := s.Conclusion.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"conclusion\"")
}
case "html_url":
requiredBitSet[0] |= 1 << 6
if err := func() error {
v, err := json.DecodeURI(d)
s.HTMLURL = v
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"html_url\"")
}
case "created_at":
if err := func() error {
s.CreatedAt.Reset()
if err := s.CreatedAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"created_at\"")
}
case "updated_at":
if err := func() error {
s.UpdatedAt.Reset()
if err := s.UpdatedAt.Decode(d, json.DecodeDateTime); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"updated_at\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode WorkflowRun")
}
// Validate required fields.
var failures []validate.FieldError
for i, mask := range [2]uint8{
0b01010011,
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(jsonFieldsNameOfWorkflowRun) {
name = jsonFieldsNameOfWorkflowRun[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 *WorkflowRun) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *WorkflowRun) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *WorkflowRunsResponse) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *WorkflowRunsResponse) encodeFields(e *jx.Encoder) {
{
e.FieldStart("total_count")
e.Int(s.TotalCount)
}
{
e.FieldStart("workflow_runs")
e.ArrStart()
for _, elem := range s.WorkflowRuns {
elem.Encode(e)
}
e.ArrEnd()
}
}
var jsonFieldsNameOfWorkflowRunsResponse = [2]string{
0: "total_count",
1: "workflow_runs",
}
// Decode decodes WorkflowRunsResponse from json.
func (s *WorkflowRunsResponse) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode WorkflowRunsResponse to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "total_count":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Int()
s.TotalCount = int(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"total_count\"")
}
case "workflow_runs":
requiredBitSet[0] |= 1 << 1
if err := func() error {
s.WorkflowRuns = make([]WorkflowRun, 0)
if err := d.Arr(func(d *jx.Decoder) error {
var elem WorkflowRun
if err := elem.Decode(d); err != nil {
return err
}
s.WorkflowRuns = append(s.WorkflowRuns, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"workflow_runs\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode WorkflowRunsResponse")
}
// 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(jsonFieldsNameOfWorkflowRunsResponse) {
name = jsonFieldsNameOfWorkflowRunsResponse[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 *WorkflowRunsResponse) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *WorkflowRunsResponse) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *WorkflowsResponse) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *WorkflowsResponse) encodeFields(e *jx.Encoder) {
{
e.FieldStart("total_count")
e.Int(s.TotalCount)
}
{
e.FieldStart("workflows")
e.ArrStart()
for _, elem := range s.Workflows {
elem.Encode(e)
}
e.ArrEnd()
}
}
var jsonFieldsNameOfWorkflowsResponse = [2]string{
0: "total_count",
1: "workflows",
}
// Decode decodes WorkflowsResponse from json.
func (s *WorkflowsResponse) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode WorkflowsResponse to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "total_count":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Int()
s.TotalCount = int(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"total_count\"")
}
case "workflows":
requiredBitSet[0] |= 1 << 1
if err := func() error {
s.Workflows = make([]Workflow, 0)
if err := d.Arr(func(d *jx.Decoder) error {
var elem Workflow
if err := elem.Decode(d); err != nil {
return err
}
s.Workflows = append(s.Workflows, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"workflows\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode WorkflowsResponse")
}
// 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(jsonFieldsNameOfWorkflowsResponse) {
name = jsonFieldsNameOfWorkflowsResponse[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 *WorkflowsResponse) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *WorkflowsResponse) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
