// Code generated by ogen, DO NOT EDIT.
package gen
import (
"math/bits"
"strconv"
"github.com/go-faster/errors"
"github.com/go-faster/jx"
"github.com/ogen-go/ogen/validate"
)
// Encode implements json.Marshaler.
func (s *Comment) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *Comment) encodeFields(e *jx.Encoder) {
{
if s.ID.Set {
e.FieldStart("id")
s.ID.Encode(e)
}
}
{
if s.TaskId.Set {
e.FieldStart("taskId")
s.TaskId.Encode(e)
}
}
{
if s.ProjectId.Set {
e.FieldStart("projectId")
s.ProjectId.Encode(e)
}
}
{
if s.PostedAt.Set {
e.FieldStart("postedAt")
s.PostedAt.Encode(e)
}
}
{
if s.Content.Set {
e.FieldStart("content")
s.Content.Encode(e)
}
}
{
if len(s.FileAttachment) != 0 {
e.FieldStart("fileAttachment")
e.Raw(s.FileAttachment)
}
}
}
var jsonFieldsNameOfComment = [6]string{
0: "id",
1: "taskId",
2: "projectId",
3: "postedAt",
4: "content",
5: "fileAttachment",
}
// Decode decodes Comment from json.
func (s *Comment) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode Comment to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "id":
if err := func() error {
s.ID.Reset()
if err := s.ID.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"id\"")
}
case "taskId":
if err := func() error {
s.TaskId.Reset()
if err := s.TaskId.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"taskId\"")
}
case "projectId":
if err := func() error {
s.ProjectId.Reset()
if err := s.ProjectId.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"projectId\"")
}
case "postedAt":
if err := func() error {
s.PostedAt.Reset()
if err := s.PostedAt.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"postedAt\"")
}
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 "fileAttachment":
if err := func() error {
v, err := d.RawAppend(nil)
s.FileAttachment = jx.Raw(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"fileAttachment\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode Comment")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *Comment) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Comment) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *CommentListResponse) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *CommentListResponse) encodeFields(e *jx.Encoder) {
{
if s.Results != nil {
e.FieldStart("results")
e.ArrStart()
for _, elem := range s.Results {
elem.Encode(e)
}
e.ArrEnd()
}
}
{
if s.NextCursor.Set {
e.FieldStart("nextCursor")
s.NextCursor.Encode(e)
}
}
}
var jsonFieldsNameOfCommentListResponse = [2]string{
0: "results",
1: "nextCursor",
}
// Decode decodes CommentListResponse from json.
func (s *CommentListResponse) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode CommentListResponse to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "results":
if err := func() error {
s.Results = make([]Comment, 0)
if err := d.Arr(func(d *jx.Decoder) error {
var elem Comment
if err := elem.Decode(d); err != nil {
return err
}
s.Results = append(s.Results, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"results\"")
}
case "nextCursor":
if err := func() error {
s.NextCursor.Reset()
if err := s.NextCursor.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"nextCursor\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode CommentListResponse")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *CommentListResponse) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CommentListResponse) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *CreateCommentReq) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *CreateCommentReq) encodeFields(e *jx.Encoder) {
{
if s.TaskId.Set {
e.FieldStart("taskId")
s.TaskId.Encode(e)
}
}
{
if s.ProjectId.Set {
e.FieldStart("projectId")
s.ProjectId.Encode(e)
}
}
{
e.FieldStart("content")
e.Str(s.Content)
}
}
var jsonFieldsNameOfCreateCommentReq = [3]string{
0: "taskId",
1: "projectId",
2: "content",
}
// Decode decodes CreateCommentReq from json.
func (s *CreateCommentReq) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode CreateCommentReq to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "taskId":
if err := func() error {
s.TaskId.Reset()
if err := s.TaskId.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"taskId\"")
}
case "projectId":
if err := func() error {
s.ProjectId.Reset()
if err := s.ProjectId.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"projectId\"")
}
case "content":
requiredBitSet[0] |= 1 << 2
if err := func() error {
v, err := d.Str()
s.Content = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"content\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode CreateCommentReq")
}
// Validate required fields.
var failures []validate.FieldError
for i, mask := range [1]uint8{
0b00000100,
} {
if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
// Mask only required fields and check equality to mask using XOR.
//
// If XOR result is not zero, result is not equal to expected, so some fields are missed.
// Bits of fields which would be set are actually bits of missed fields.
missed := bits.OnesCount8(result)
for bitN := 0; bitN < missed; bitN++ {
bitIdx := bits.TrailingZeros8(result)
fieldIdx := i*8 + bitIdx
var name string
if fieldIdx < len(jsonFieldsNameOfCreateCommentReq) {
name = jsonFieldsNameOfCreateCommentReq[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 *CreateCommentReq) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CreateCommentReq) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *CreateTaskReq) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *CreateTaskReq) encodeFields(e *jx.Encoder) {
{
e.FieldStart("content")
e.Str(s.Content)
}
{
if s.Description.Set {
e.FieldStart("description")
s.Description.Encode(e)
}
}
{
if s.ProjectId.Set {
e.FieldStart("projectId")
s.ProjectId.Encode(e)
}
}
{
if s.SectionId.Set {
e.FieldStart("sectionId")
s.SectionId.Encode(e)
}
}
{
if s.ParentId.Set {
e.FieldStart("parentId")
s.ParentId.Encode(e)
}
}
{
if s.Priority.Set {
e.FieldStart("priority")
s.Priority.Encode(e)
}
}
{
if s.DueString.Set {
e.FieldStart("dueString")
s.DueString.Encode(e)
}
}
{
if s.DueDate.Set {
e.FieldStart("dueDate")
s.DueDate.Encode(e)
}
}
{
if s.DueDatetime.Set {
e.FieldStart("dueDatetime")
s.DueDatetime.Encode(e)
}
}
{
if s.Labels != nil {
e.FieldStart("labels")
e.ArrStart()
for _, elem := range s.Labels {
e.Str(elem)
}
e.ArrEnd()
}
}
{
if s.AssigneeId.Set {
e.FieldStart("assigneeId")
s.AssigneeId.Encode(e)
}
}
}
var jsonFieldsNameOfCreateTaskReq = [11]string{
0: "content",
1: "description",
2: "projectId",
3: "sectionId",
4: "parentId",
5: "priority",
6: "dueString",
7: "dueDate",
8: "dueDatetime",
9: "labels",
10: "assigneeId",
}
// Decode decodes CreateTaskReq from json.
func (s *CreateTaskReq) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode CreateTaskReq to nil")
}
var requiredBitSet [2]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "content":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Str()
s.Content = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"content\"")
}
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 "projectId":
if err := func() error {
s.ProjectId.Reset()
if err := s.ProjectId.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"projectId\"")
}
case "sectionId":
if err := func() error {
s.SectionId.Reset()
if err := s.SectionId.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"sectionId\"")
}
case "parentId":
if err := func() error {
s.ParentId.Reset()
if err := s.ParentId.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"parentId\"")
}
case "priority":
if err := func() error {
s.Priority.Reset()
if err := s.Priority.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"priority\"")
}
case "dueString":
if err := func() error {
s.DueString.Reset()
if err := s.DueString.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"dueString\"")
}
case "dueDate":
if err := func() error {
s.DueDate.Reset()
if err := s.DueDate.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"dueDate\"")
}
case "dueDatetime":
if err := func() error {
s.DueDatetime.Reset()
if err := s.DueDatetime.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"dueDatetime\"")
}
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 "assigneeId":
if err := func() error {
s.AssigneeId.Reset()
if err := s.AssigneeId.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"assigneeId\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode CreateTaskReq")
}
// Validate required fields.
var failures []validate.FieldError
for i, mask := range [2]uint8{
0b00000001,
0b00000000,
} {
if result := (requiredBitSet[i] & mask) ^ mask; result != 0 {
// Mask only required fields and check equality to mask using XOR.
//
// If XOR result is not zero, result is not equal to expected, so some fields are missed.
// Bits of fields which would be set are actually bits of missed fields.
missed := bits.OnesCount8(result)
for bitN := 0; bitN < missed; bitN++ {
bitIdx := bits.TrailingZeros8(result)
fieldIdx := i*8 + bitIdx
var name string
if fieldIdx < len(jsonFieldsNameOfCreateTaskReq) {
name = jsonFieldsNameOfCreateTaskReq[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 *CreateTaskReq) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CreateTaskReq) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *Due) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *Due) encodeFields(e *jx.Encoder) {
{
if s.String.Set {
e.FieldStart("string")
s.String.Encode(e)
}
}
{
if s.Date.Set {
e.FieldStart("date")
s.Date.Encode(e)
}
}
{
if s.IsRecurring.Set {
e.FieldStart("isRecurring")
s.IsRecurring.Encode(e)
}
}
{
if s.Datetime.Set {
e.FieldStart("datetime")
s.Datetime.Encode(e)
}
}
{
if s.Timezone.Set {
e.FieldStart("timezone")
s.Timezone.Encode(e)
}
}
{
if s.Lang.Set {
e.FieldStart("lang")
s.Lang.Encode(e)
}
}
}
var jsonFieldsNameOfDue = [6]string{
0: "string",
1: "date",
2: "isRecurring",
3: "datetime",
4: "timezone",
5: "lang",
}
// Decode decodes Due from json.
func (s *Due) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode Due to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "string":
if err := func() error {
s.String.Reset()
if err := s.String.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"string\"")
}
case "date":
if err := func() error {
s.Date.Reset()
if err := s.Date.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"date\"")
}
case "isRecurring":
if err := func() error {
s.IsRecurring.Reset()
if err := s.IsRecurring.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"isRecurring\"")
}
case "datetime":
if err := func() error {
s.Datetime.Reset()
if err := s.Datetime.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"datetime\"")
}
case "timezone":
if err := func() error {
s.Timezone.Reset()
if err := s.Timezone.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"timezone\"")
}
case "lang":
if err := func() error {
s.Lang.Reset()
if err := s.Lang.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"lang\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode Due")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *Due) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Due) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *Duration) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *Duration) encodeFields(e *jx.Encoder) {
{
if s.Amount.Set {
e.FieldStart("amount")
s.Amount.Encode(e)
}
}
{
if s.Unit.Set {
e.FieldStart("unit")
s.Unit.Encode(e)
}
}
}
var jsonFieldsNameOfDuration = [2]string{
0: "amount",
1: "unit",
}
// Decode decodes Duration from json.
func (s *Duration) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode Duration to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "amount":
if err := func() error {
s.Amount.Reset()
if err := s.Amount.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"amount\"")
}
case "unit":
if err := func() error {
s.Unit.Reset()
if err := s.Unit.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"unit\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode Duration")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *Duration) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Duration) 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.ID.Set {
e.FieldStart("id")
s.ID.Encode(e)
}
}
{
if s.Name.Set {
e.FieldStart("name")
s.Name.Encode(e)
}
}
{
if s.Color.Set {
e.FieldStart("color")
s.Color.Encode(e)
}
}
{
if s.Order.Set {
e.FieldStart("order")
s.Order.Encode(e)
}
}
{
if s.IsFavorite.Set {
e.FieldStart("isFavorite")
s.IsFavorite.Encode(e)
}
}
}
var jsonFieldsNameOfLabel = [5]string{
0: "id",
1: "name",
2: "color",
3: "order",
4: "isFavorite",
}
// 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 "id":
if err := func() error {
s.ID.Reset()
if err := s.ID.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"id\"")
}
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\"")
}
case "order":
if err := func() error {
s.Order.Reset()
if err := s.Order.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"order\"")
}
case "isFavorite":
if err := func() error {
s.IsFavorite.Reset()
if err := s.IsFavorite.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"isFavorite\"")
}
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 implements json.Marshaler.
func (s *LabelListResponse) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *LabelListResponse) encodeFields(e *jx.Encoder) {
{
if s.Results != nil {
e.FieldStart("results")
e.ArrStart()
for _, elem := range s.Results {
elem.Encode(e)
}
e.ArrEnd()
}
}
{
if s.NextCursor.Set {
e.FieldStart("nextCursor")
s.NextCursor.Encode(e)
}
}
}
var jsonFieldsNameOfLabelListResponse = [2]string{
0: "results",
1: "nextCursor",
}
// Decode decodes LabelListResponse from json.
func (s *LabelListResponse) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode LabelListResponse to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "results":
if err := func() error {
s.Results = 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.Results = append(s.Results, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"results\"")
}
case "nextCursor":
if err := func() error {
s.NextCursor.Reset()
if err := s.NextCursor.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"nextCursor\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode LabelListResponse")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *LabelListResponse) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *LabelListResponse) 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 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 Due as json.
func (o OptNilDue) Encode(e *jx.Encoder) {
if !o.Set {
return
}
if o.Null {
e.Null()
return
}
o.Value.Encode(e)
}
// Decode decodes Due from json.
func (o *OptNilDue) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptNilDue to nil")
}
if d.Next() == jx.Null {
if err := d.Null(); err != nil {
return err
}
var v Due
o.Value = v
o.Set = true
o.Null = true
return nil
}
o.Set = true
o.Null = false
if err := o.Value.Decode(d); err != nil {
return err
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptNilDue) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptNilDue) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode encodes Duration as json.
func (o OptNilDuration) Encode(e *jx.Encoder) {
if !o.Set {
return
}
if o.Null {
e.Null()
return
}
o.Value.Encode(e)
}
// Decode decodes Duration from json.
func (o *OptNilDuration) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptNilDuration to nil")
}
if d.Next() == jx.Null {
if err := d.Null(); err != nil {
return err
}
var v Duration
o.Value = v
o.Set = true
o.Null = true
return nil
}
o.Set = true
o.Null = false
if err := o.Value.Decode(d); err != nil {
return err
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptNilDuration) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptNilDuration) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode encodes int as json.
func (o OptNilInt) Encode(e *jx.Encoder) {
if !o.Set {
return
}
if o.Null {
e.Null()
return
}
e.Int(int(o.Value))
}
// Decode decodes int from json.
func (o *OptNilInt) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptNilInt to nil")
}
if d.Next() == jx.Null {
if err := d.Null(); err != nil {
return err
}
var v int
o.Value = v
o.Set = true
o.Null = true
return nil
}
o.Set = true
o.Null = false
v, err := d.Int()
if err != nil {
return err
}
o.Value = int(v)
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptNilInt) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptNilInt) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode encodes string as json.
func (o OptNilString) Encode(e *jx.Encoder) {
if !o.Set {
return
}
if o.Null {
e.Null()
return
}
e.Str(string(o.Value))
}
// Decode decodes string from json.
func (o *OptNilString) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptNilString to nil")
}
if d.Next() == jx.Null {
if err := d.Null(); err != nil {
return err
}
var v string
o.Value = v
o.Set = true
o.Null = true
return nil
}
o.Set = true
o.Null = false
v, err := d.Str()
if err != nil {
return err
}
o.Value = string(v)
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptNilString) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptNilString) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode encodes string as json.
func (o OptString) Encode(e *jx.Encoder) {
if !o.Set {
return
}
e.Str(string(o.Value))
}
// Decode decodes string from json.
func (o *OptString) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptString to nil")
}
o.Set = true
v, err := d.Str()
if err != nil {
return err
}
o.Value = string(v)
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptString) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptString) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *Project) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *Project) encodeFields(e *jx.Encoder) {
{
if s.ID.Set {
e.FieldStart("id")
s.ID.Encode(e)
}
}
{
if s.Name.Set {
e.FieldStart("name")
s.Name.Encode(e)
}
}
{
if s.Color.Set {
e.FieldStart("color")
s.Color.Encode(e)
}
}
{
if s.ParentId.Set {
e.FieldStart("parentId")
s.ParentId.Encode(e)
}
}
{
if s.ChildOrder.Set {
e.FieldStart("childOrder")
s.ChildOrder.Encode(e)
}
}
{
if s.IsArchived.Set {
e.FieldStart("isArchived")
s.IsArchived.Encode(e)
}
}
{
if s.IsDeleted.Set {
e.FieldStart("isDeleted")
s.IsDeleted.Encode(e)
}
}
{
if s.IsFavorite.Set {
e.FieldStart("isFavorite")
s.IsFavorite.Encode(e)
}
}
{
if s.IsShared.Set {
e.FieldStart("isShared")
s.IsShared.Encode(e)
}
}
{
if s.InboxProject.Set {
e.FieldStart("inboxProject")
s.InboxProject.Encode(e)
}
}
{
if s.ViewStyle.Set {
e.FieldStart("viewStyle")
s.ViewStyle.Encode(e)
}
}
{
if s.Description.Set {
e.FieldStart("description")
s.Description.Encode(e)
}
}
{
if s.URL.Set {
e.FieldStart("url")
s.URL.Encode(e)
}
}
}
var jsonFieldsNameOfProject = [13]string{
0: "id",
1: "name",
2: "color",
3: "parentId",
4: "childOrder",
5: "isArchived",
6: "isDeleted",
7: "isFavorite",
8: "isShared",
9: "inboxProject",
10: "viewStyle",
11: "description",
12: "url",
}
// Decode decodes Project from json.
func (s *Project) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode Project to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "id":
if err := func() error {
s.ID.Reset()
if err := s.ID.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"id\"")
}
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\"")
}
case "parentId":
if err := func() error {
s.ParentId.Reset()
if err := s.ParentId.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"parentId\"")
}
case "childOrder":
if err := func() error {
s.ChildOrder.Reset()
if err := s.ChildOrder.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"childOrder\"")
}
case "isArchived":
if err := func() error {
s.IsArchived.Reset()
if err := s.IsArchived.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"isArchived\"")
}
case "isDeleted":
if err := func() error {
s.IsDeleted.Reset()
if err := s.IsDeleted.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"isDeleted\"")
}
case "isFavorite":
if err := func() error {
s.IsFavorite.Reset()
if err := s.IsFavorite.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"isFavorite\"")
}
case "isShared":
if err := func() error {
s.IsShared.Reset()
if err := s.IsShared.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"isShared\"")
}
case "inboxProject":
if err := func() error {
s.InboxProject.Reset()
if err := s.InboxProject.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"inboxProject\"")
}
case "viewStyle":
if err := func() error {
s.ViewStyle.Reset()
if err := s.ViewStyle.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"viewStyle\"")
}
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 "url":
if err := func() error {
s.URL.Reset()
if err := s.URL.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"url\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode Project")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *Project) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Project) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *ProjectListResponse) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *ProjectListResponse) encodeFields(e *jx.Encoder) {
{
if s.Results != nil {
e.FieldStart("results")
e.ArrStart()
for _, elem := range s.Results {
elem.Encode(e)
}
e.ArrEnd()
}
}
{
if s.NextCursor.Set {
e.FieldStart("nextCursor")
s.NextCursor.Encode(e)
}
}
}
var jsonFieldsNameOfProjectListResponse = [2]string{
0: "results",
1: "nextCursor",
}
// Decode decodes ProjectListResponse from json.
func (s *ProjectListResponse) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode ProjectListResponse to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "results":
if err := func() error {
s.Results = make([]Project, 0)
if err := d.Arr(func(d *jx.Decoder) error {
var elem Project
if err := elem.Decode(d); err != nil {
return err
}
s.Results = append(s.Results, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"results\"")
}
case "nextCursor":
if err := func() error {
s.NextCursor.Reset()
if err := s.NextCursor.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"nextCursor\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode ProjectListResponse")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *ProjectListResponse) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ProjectListResponse) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *Section) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *Section) encodeFields(e *jx.Encoder) {
{
if s.ID.Set {
e.FieldStart("id")
s.ID.Encode(e)
}
}
{
if s.ProjectId.Set {
e.FieldStart("projectId")
s.ProjectId.Encode(e)
}
}
{
if s.Name.Set {
e.FieldStart("name")
s.Name.Encode(e)
}
}
{
if s.SectionOrder.Set {
e.FieldStart("sectionOrder")
s.SectionOrder.Encode(e)
}
}
{
if s.IsArchived.Set {
e.FieldStart("isArchived")
s.IsArchived.Encode(e)
}
}
{
if s.IsDeleted.Set {
e.FieldStart("isDeleted")
s.IsDeleted.Encode(e)
}
}
}
var jsonFieldsNameOfSection = [6]string{
0: "id",
1: "projectId",
2: "name",
3: "sectionOrder",
4: "isArchived",
5: "isDeleted",
}
// Decode decodes Section from json.
func (s *Section) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode Section to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "id":
if err := func() error {
s.ID.Reset()
if err := s.ID.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"id\"")
}
case "projectId":
if err := func() error {
s.ProjectId.Reset()
if err := s.ProjectId.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"projectId\"")
}
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 "sectionOrder":
if err := func() error {
s.SectionOrder.Reset()
if err := s.SectionOrder.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"sectionOrder\"")
}
case "isArchived":
if err := func() error {
s.IsArchived.Reset()
if err := s.IsArchived.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"isArchived\"")
}
case "isDeleted":
if err := func() error {
s.IsDeleted.Reset()
if err := s.IsDeleted.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"isDeleted\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode Section")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *Section) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Section) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *SectionListResponse) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *SectionListResponse) encodeFields(e *jx.Encoder) {
{
if s.Results != nil {
e.FieldStart("results")
e.ArrStart()
for _, elem := range s.Results {
elem.Encode(e)
}
e.ArrEnd()
}
}
{
if s.NextCursor.Set {
e.FieldStart("nextCursor")
s.NextCursor.Encode(e)
}
}
}
var jsonFieldsNameOfSectionListResponse = [2]string{
0: "results",
1: "nextCursor",
}
// Decode decodes SectionListResponse from json.
func (s *SectionListResponse) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode SectionListResponse to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "results":
if err := func() error {
s.Results = make([]Section, 0)
if err := d.Arr(func(d *jx.Decoder) error {
var elem Section
if err := elem.Decode(d); err != nil {
return err
}
s.Results = append(s.Results, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"results\"")
}
case "nextCursor":
if err := func() error {
s.NextCursor.Reset()
if err := s.NextCursor.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"nextCursor\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode SectionListResponse")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *SectionListResponse) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *SectionListResponse) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *Task) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *Task) encodeFields(e *jx.Encoder) {
{
if s.ID.Set {
e.FieldStart("id")
s.ID.Encode(e)
}
}
{
if s.ProjectId.Set {
e.FieldStart("projectId")
s.ProjectId.Encode(e)
}
}
{
if s.SectionId.Set {
e.FieldStart("sectionId")
s.SectionId.Encode(e)
}
}
{
if s.ParentId.Set {
e.FieldStart("parentId")
s.ParentId.Encode(e)
}
}
{
if s.Content.Set {
e.FieldStart("content")
s.Content.Encode(e)
}
}
{
if s.Description.Set {
e.FieldStart("description")
s.Description.Encode(e)
}
}
{
if s.Checked.Set {
e.FieldStart("checked")
s.Checked.Encode(e)
}
}
{
if s.Labels != nil {
e.FieldStart("labels")
e.ArrStart()
for _, elem := range s.Labels {
e.Str(elem)
}
e.ArrEnd()
}
}
{
if s.Priority.Set {
e.FieldStart("priority")
s.Priority.Encode(e)
}
}
{
if s.ChildOrder.Set {
e.FieldStart("childOrder")
s.ChildOrder.Encode(e)
}
}
{
if s.Due.Set {
e.FieldStart("due")
s.Due.Encode(e)
}
}
{
if s.Duration.Set {
e.FieldStart("duration")
s.Duration.Encode(e)
}
}
{
if s.NoteCount.Set {
e.FieldStart("noteCount")
s.NoteCount.Encode(e)
}
}
{
if s.URL.Set {
e.FieldStart("url")
s.URL.Encode(e)
}
}
{
if s.AddedAt.Set {
e.FieldStart("addedAt")
s.AddedAt.Encode(e)
}
}
{
if s.CompletedAt.Set {
e.FieldStart("completedAt")
s.CompletedAt.Encode(e)
}
}
{
if s.ResponsibleUid.Set {
e.FieldStart("responsibleUid")
s.ResponsibleUid.Encode(e)
}
}
}
var jsonFieldsNameOfTask = [17]string{
0: "id",
1: "projectId",
2: "sectionId",
3: "parentId",
4: "content",
5: "description",
6: "checked",
7: "labels",
8: "priority",
9: "childOrder",
10: "due",
11: "duration",
12: "noteCount",
13: "url",
14: "addedAt",
15: "completedAt",
16: "responsibleUid",
}
// Decode decodes Task from json.
func (s *Task) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode Task to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "id":
if err := func() error {
s.ID.Reset()
if err := s.ID.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"id\"")
}
case "projectId":
if err := func() error {
s.ProjectId.Reset()
if err := s.ProjectId.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"projectId\"")
}
case "sectionId":
if err := func() error {
s.SectionId.Reset()
if err := s.SectionId.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"sectionId\"")
}
case "parentId":
if err := func() error {
s.ParentId.Reset()
if err := s.ParentId.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"parentId\"")
}
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 "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 "checked":
if err := func() error {
s.Checked.Reset()
if err := s.Checked.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"checked\"")
}
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 "priority":
if err := func() error {
s.Priority.Reset()
if err := s.Priority.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"priority\"")
}
case "childOrder":
if err := func() error {
s.ChildOrder.Reset()
if err := s.ChildOrder.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"childOrder\"")
}
case "due":
if err := func() error {
s.Due.Reset()
if err := s.Due.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"due\"")
}
case "duration":
if err := func() error {
s.Duration.Reset()
if err := s.Duration.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"duration\"")
}
case "noteCount":
if err := func() error {
s.NoteCount.Reset()
if err := s.NoteCount.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"noteCount\"")
}
case "url":
if err := func() error {
s.URL.Reset()
if err := s.URL.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"url\"")
}
case "addedAt":
if err := func() error {
s.AddedAt.Reset()
if err := s.AddedAt.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"addedAt\"")
}
case "completedAt":
if err := func() error {
s.CompletedAt.Reset()
if err := s.CompletedAt.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"completedAt\"")
}
case "responsibleUid":
if err := func() error {
s.ResponsibleUid.Reset()
if err := s.ResponsibleUid.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"responsibleUid\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode Task")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *Task) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Task) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *TaskListResponse) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *TaskListResponse) encodeFields(e *jx.Encoder) {
{
if s.Results != nil {
e.FieldStart("results")
e.ArrStart()
for _, elem := range s.Results {
elem.Encode(e)
}
e.ArrEnd()
}
}
{
if s.NextCursor.Set {
e.FieldStart("nextCursor")
s.NextCursor.Encode(e)
}
}
}
var jsonFieldsNameOfTaskListResponse = [2]string{
0: "results",
1: "nextCursor",
}
// Decode decodes TaskListResponse from json.
func (s *TaskListResponse) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode TaskListResponse to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "results":
if err := func() error {
s.Results = make([]Task, 0)
if err := d.Arr(func(d *jx.Decoder) error {
var elem Task
if err := elem.Decode(d); err != nil {
return err
}
s.Results = append(s.Results, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"results\"")
}
case "nextCursor":
if err := func() error {
s.NextCursor.Reset()
if err := s.NextCursor.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"nextCursor\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode TaskListResponse")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *TaskListResponse) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *TaskListResponse) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *UpdateCommentReq) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *UpdateCommentReq) encodeFields(e *jx.Encoder) {
{
e.FieldStart("content")
e.Str(s.Content)
}
}
var jsonFieldsNameOfUpdateCommentReq = [1]string{
0: "content",
}
// Decode decodes UpdateCommentReq from json.
func (s *UpdateCommentReq) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode UpdateCommentReq to nil")
}
var requiredBitSet [1]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "content":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Str()
s.Content = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"content\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode UpdateCommentReq")
}
// 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(jsonFieldsNameOfUpdateCommentReq) {
name = jsonFieldsNameOfUpdateCommentReq[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 *UpdateCommentReq) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *UpdateCommentReq) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *UpdateTaskReq) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *UpdateTaskReq) encodeFields(e *jx.Encoder) {
{
if s.Content.Set {
e.FieldStart("content")
s.Content.Encode(e)
}
}
{
if s.Description.Set {
e.FieldStart("description")
s.Description.Encode(e)
}
}
{
if s.Priority.Set {
e.FieldStart("priority")
s.Priority.Encode(e)
}
}
{
if s.DueString.Set {
e.FieldStart("dueString")
s.DueString.Encode(e)
}
}
{
if s.DueDate.Set {
e.FieldStart("dueDate")
s.DueDate.Encode(e)
}
}
{
if s.DueDatetime.Set {
e.FieldStart("dueDatetime")
s.DueDatetime.Encode(e)
}
}
{
if s.Labels != nil {
e.FieldStart("labels")
e.ArrStart()
for _, elem := range s.Labels {
e.Str(elem)
}
e.ArrEnd()
}
}
{
if s.AssigneeId.Set {
e.FieldStart("assigneeId")
s.AssigneeId.Encode(e)
}
}
}
var jsonFieldsNameOfUpdateTaskReq = [8]string{
0: "content",
1: "description",
2: "priority",
3: "dueString",
4: "dueDate",
5: "dueDatetime",
6: "labels",
7: "assigneeId",
}
// Decode decodes UpdateTaskReq from json.
func (s *UpdateTaskReq) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode UpdateTaskReq to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
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 "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 "priority":
if err := func() error {
s.Priority.Reset()
if err := s.Priority.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"priority\"")
}
case "dueString":
if err := func() error {
s.DueString.Reset()
if err := s.DueString.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"dueString\"")
}
case "dueDate":
if err := func() error {
s.DueDate.Reset()
if err := s.DueDate.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"dueDate\"")
}
case "dueDatetime":
if err := func() error {
s.DueDatetime.Reset()
if err := s.DueDatetime.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"dueDatetime\"")
}
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 "assigneeId":
if err := func() error {
s.AssigneeId.Reset()
if err := s.AssigneeId.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"assigneeId\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode UpdateTaskReq")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *UpdateTaskReq) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *UpdateTaskReq) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
