// 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 *ChecklistItem) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *ChecklistItem) encodeFields(e *jx.Encoder) {
{
if s.ID.Set {
e.FieldStart("id")
s.ID.Encode(e)
}
}
{
if s.Title.Set {
e.FieldStart("title")
s.Title.Encode(e)
}
}
{
if s.Status.Set {
e.FieldStart("status")
s.Status.Encode(e)
}
}
{
if s.SortOrder.Set {
e.FieldStart("sortOrder")
s.SortOrder.Encode(e)
}
}
{
if s.StartDate.Set {
e.FieldStart("startDate")
s.StartDate.Encode(e)
}
}
{
if s.IsAllDay.Set {
e.FieldStart("isAllDay")
s.IsAllDay.Encode(e)
}
}
{
if s.TimeZone.Set {
e.FieldStart("timeZone")
s.TimeZone.Encode(e)
}
}
{
if s.CompletedTime.Set {
e.FieldStart("completedTime")
s.CompletedTime.Encode(e)
}
}
}
var jsonFieldsNameOfChecklistItem = [8]string{
0: "id",
1: "title",
2: "status",
3: "sortOrder",
4: "startDate",
5: "isAllDay",
6: "timeZone",
7: "completedTime",
}
// Decode decodes ChecklistItem from json.
func (s *ChecklistItem) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode ChecklistItem 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 "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 "status":
if err := func() error {
s.Status.Reset()
if err := s.Status.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"status\"")
}
case "sortOrder":
if err := func() error {
s.SortOrder.Reset()
if err := s.SortOrder.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"sortOrder\"")
}
case "startDate":
if err := func() error {
s.StartDate.Reset()
if err := s.StartDate.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"startDate\"")
}
case "isAllDay":
if err := func() error {
s.IsAllDay.Reset()
if err := s.IsAllDay.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"isAllDay\"")
}
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 "completedTime":
if err := func() error {
s.CompletedTime.Reset()
if err := s.CompletedTime.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"completedTime\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode ChecklistItem")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *ChecklistItem) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ChecklistItem) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *Column) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *Column) 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.SortOrder.Set {
e.FieldStart("sortOrder")
s.SortOrder.Encode(e)
}
}
}
var jsonFieldsNameOfColumn = [4]string{
0: "id",
1: "projectId",
2: "name",
3: "sortOrder",
}
// Decode decodes Column from json.
func (s *Column) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode Column 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 "sortOrder":
if err := func() error {
s.SortOrder.Reset()
if err := s.SortOrder.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"sortOrder\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode Column")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *Column) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *Column) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode implements json.Marshaler.
func (s *CreateProjectReq) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *CreateProjectReq) encodeFields(e *jx.Encoder) {
{
e.FieldStart("name")
e.Str(s.Name)
}
{
if s.Color.Set {
e.FieldStart("color")
s.Color.Encode(e)
}
}
{
if s.ViewMode.Set {
e.FieldStart("viewMode")
s.ViewMode.Encode(e)
}
}
{
if s.Kind.Set {
e.FieldStart("kind")
s.Kind.Encode(e)
}
}
}
var jsonFieldsNameOfCreateProjectReq = [4]string{
0: "name",
1: "color",
2: "viewMode",
3: "kind",
}
// Decode decodes CreateProjectReq from json.
func (s *CreateProjectReq) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode CreateProjectReq 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 "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 "viewMode":
if err := func() error {
s.ViewMode.Reset()
if err := s.ViewMode.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"viewMode\"")
}
case "kind":
if err := func() error {
s.Kind.Reset()
if err := s.Kind.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"kind\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode CreateProjectReq")
}
// 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(jsonFieldsNameOfCreateProjectReq) {
name = jsonFieldsNameOfCreateProjectReq[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 *CreateProjectReq) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *CreateProjectReq) 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("title")
e.Str(s.Title)
}
{
if s.ProjectId.Set {
e.FieldStart("projectId")
s.ProjectId.Encode(e)
}
}
{
if s.Content.Set {
e.FieldStart("content")
s.Content.Encode(e)
}
}
{
if s.Desc.Set {
e.FieldStart("desc")
s.Desc.Encode(e)
}
}
{
if s.IsAllDay.Set {
e.FieldStart("isAllDay")
s.IsAllDay.Encode(e)
}
}
{
if s.StartDate.Set {
e.FieldStart("startDate")
s.StartDate.Encode(e)
}
}
{
if s.DueDate.Set {
e.FieldStart("dueDate")
s.DueDate.Encode(e)
}
}
{
if s.TimeZone.Set {
e.FieldStart("timeZone")
s.TimeZone.Encode(e)
}
}
{
if s.Reminders != nil {
e.FieldStart("reminders")
e.ArrStart()
for _, elem := range s.Reminders {
e.Str(elem)
}
e.ArrEnd()
}
}
{
if s.RepeatFlag.Set {
e.FieldStart("repeatFlag")
s.RepeatFlag.Encode(e)
}
}
{
if s.Priority.Set {
e.FieldStart("priority")
s.Priority.Encode(e)
}
}
{
if s.SortOrder.Set {
e.FieldStart("sortOrder")
s.SortOrder.Encode(e)
}
}
{
if s.Items != nil {
e.FieldStart("items")
e.ArrStart()
for _, elem := range s.Items {
elem.Encode(e)
}
e.ArrEnd()
}
}
}
var jsonFieldsNameOfCreateTaskReq = [13]string{
0: "title",
1: "projectId",
2: "content",
3: "desc",
4: "isAllDay",
5: "startDate",
6: "dueDate",
7: "timeZone",
8: "reminders",
9: "repeatFlag",
10: "priority",
11: "sortOrder",
12: "items",
}
// 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 "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 "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":
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 "desc":
if err := func() error {
s.Desc.Reset()
if err := s.Desc.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"desc\"")
}
case "isAllDay":
if err := func() error {
s.IsAllDay.Reset()
if err := s.IsAllDay.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"isAllDay\"")
}
case "startDate":
if err := func() error {
s.StartDate.Reset()
if err := s.StartDate.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"startDate\"")
}
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 "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 "reminders":
if err := func() error {
s.Reminders = 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.Reminders = append(s.Reminders, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"reminders\"")
}
case "repeatFlag":
if err := func() error {
s.RepeatFlag.Reset()
if err := s.RepeatFlag.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"repeatFlag\"")
}
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 "sortOrder":
if err := func() error {
s.SortOrder.Reset()
if err := s.SortOrder.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"sortOrder\"")
}
case "items":
if err := func() error {
s.Items = make([]ChecklistItem, 0)
if err := d.Arr(func(d *jx.Decoder) error {
var elem ChecklistItem
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 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 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 int64 as json.
func (o OptInt64) Encode(e *jx.Encoder) {
if !o.Set {
return
}
e.Int64(int64(o.Value))
}
// Decode decodes int64 from json.
func (o *OptInt64) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptInt64 to nil")
}
o.Set = true
v, err := d.Int64()
if err != nil {
return err
}
o.Value = int64(v)
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptInt64) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptInt64) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode encodes bool as json.
func (o OptNilBool) Encode(e *jx.Encoder) {
if !o.Set {
return
}
if o.Null {
e.Null()
return
}
e.Bool(bool(o.Value))
}
// Decode decodes bool from json.
func (o *OptNilBool) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptNilBool to nil")
}
if d.Next() == jx.Null {
if err := d.Null(); err != nil {
return err
}
var v bool
o.Value = v
o.Set = true
o.Null = true
return nil
}
o.Set = true
o.Null = false
v, err := d.Bool()
if err != nil {
return err
}
o.Value = bool(v)
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptNilBool) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptNilBool) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode encodes []ChecklistItem as json.
func (o OptNilChecklistItemArray) Encode(e *jx.Encoder) {
if !o.Set {
return
}
if o.Null {
e.Null()
return
}
e.ArrStart()
for _, elem := range o.Value {
elem.Encode(e)
}
e.ArrEnd()
}
// Decode decodes []ChecklistItem from json.
func (o *OptNilChecklistItemArray) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptNilChecklistItemArray to nil")
}
if d.Next() == jx.Null {
if err := d.Null(); err != nil {
return err
}
var v []ChecklistItem
o.Value = v
o.Set = true
o.Null = true
return nil
}
o.Set = true
o.Null = false
o.Value = make([]ChecklistItem, 0)
if err := d.Arr(func(d *jx.Decoder) error {
var elem ChecklistItem
if err := elem.Decode(d); err != nil {
return err
}
o.Value = append(o.Value, elem)
return nil
}); err != nil {
return err
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptNilChecklistItemArray) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptNilChecklistItemArray) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode encodes []Column as json.
func (o OptNilColumnArray) Encode(e *jx.Encoder) {
if !o.Set {
return
}
if o.Null {
e.Null()
return
}
e.ArrStart()
for _, elem := range o.Value {
elem.Encode(e)
}
e.ArrEnd()
}
// Decode decodes []Column from json.
func (o *OptNilColumnArray) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptNilColumnArray to nil")
}
if d.Next() == jx.Null {
if err := d.Null(); err != nil {
return err
}
var v []Column
o.Value = v
o.Set = true
o.Null = true
return nil
}
o.Set = true
o.Null = false
o.Value = make([]Column, 0)
if err := d.Arr(func(d *jx.Decoder) error {
var elem Column
if err := elem.Decode(d); err != nil {
return err
}
o.Value = append(o.Value, elem)
return nil
}); err != nil {
return err
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptNilColumnArray) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptNilColumnArray) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode encodes int64 as json.
func (o OptNilInt64) Encode(e *jx.Encoder) {
if !o.Set {
return
}
if o.Null {
e.Null()
return
}
e.Int64(int64(o.Value))
}
// Decode decodes int64 from json.
func (o *OptNilInt64) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptNilInt64 to nil")
}
if d.Next() == jx.Null {
if err := d.Null(); err != nil {
return err
}
var v int64
o.Value = v
o.Set = true
o.Null = true
return nil
}
o.Set = true
o.Null = false
v, err := d.Int64()
if err != nil {
return err
}
o.Value = int64(v)
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptNilInt64) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptNilInt64) 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 OptNilStringArray) Encode(e *jx.Encoder) {
if !o.Set {
return
}
if o.Null {
e.Null()
return
}
e.ArrStart()
for _, elem := range o.Value {
e.Str(elem)
}
e.ArrEnd()
}
// Decode decodes []string from json.
func (o *OptNilStringArray) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptNilStringArray 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
o.Value = 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
}
o.Value = append(o.Value, elem)
return nil
}); err != nil {
return err
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptNilStringArray) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptNilStringArray) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode encodes []Task as json.
func (o OptNilTaskArray) Encode(e *jx.Encoder) {
if !o.Set {
return
}
if o.Null {
e.Null()
return
}
e.ArrStart()
for _, elem := range o.Value {
elem.Encode(e)
}
e.ArrEnd()
}
// Decode decodes []Task from json.
func (o *OptNilTaskArray) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptNilTaskArray to nil")
}
if d.Next() == jx.Null {
if err := d.Null(); err != nil {
return err
}
var v []Task
o.Value = v
o.Set = true
o.Null = true
return nil
}
o.Set = true
o.Null = false
o.Value = make([]Task, 0)
if err := d.Arr(func(d *jx.Decoder) error {
var elem Task
if err := elem.Decode(d); err != nil {
return err
}
o.Value = append(o.Value, elem)
return nil
}); err != nil {
return err
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptNilTaskArray) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptNilTaskArray) UnmarshalJSON(data []byte) error {
d := jx.DecodeBytes(data)
return s.Decode(d)
}
// Encode encodes Project as json.
func (o OptProject) Encode(e *jx.Encoder) {
if !o.Set {
return
}
o.Value.Encode(e)
}
// Decode decodes Project from json.
func (o *OptProject) Decode(d *jx.Decoder) error {
if o == nil {
return errors.New("invalid: unable to decode OptProject to nil")
}
o.Set = true
if err := o.Value.Decode(d); err != nil {
return err
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s OptProject) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *OptProject) 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.SortOrder.Set {
e.FieldStart("sortOrder")
s.SortOrder.Encode(e)
}
}
{
if s.SortType.Set {
e.FieldStart("sortType")
s.SortType.Encode(e)
}
}
{
if s.ViewMode.Set {
e.FieldStart("viewMode")
s.ViewMode.Encode(e)
}
}
{
if s.Kind.Set {
e.FieldStart("kind")
s.Kind.Encode(e)
}
}
{
if s.GroupId.Set {
e.FieldStart("groupId")
s.GroupId.Encode(e)
}
}
{
if s.IsOwner.Set {
e.FieldStart("isOwner")
s.IsOwner.Encode(e)
}
}
{
if s.Closed.Set {
e.FieldStart("closed")
s.Closed.Encode(e)
}
}
{
if s.ModifiedTime.Set {
e.FieldStart("modifiedTime")
s.ModifiedTime.Encode(e)
}
}
}
var jsonFieldsNameOfProject = [11]string{
0: "id",
1: "name",
2: "color",
3: "sortOrder",
4: "sortType",
5: "viewMode",
6: "kind",
7: "groupId",
8: "isOwner",
9: "closed",
10: "modifiedTime",
}
// 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 "sortOrder":
if err := func() error {
s.SortOrder.Reset()
if err := s.SortOrder.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"sortOrder\"")
}
case "sortType":
if err := func() error {
s.SortType.Reset()
if err := s.SortType.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"sortType\"")
}
case "viewMode":
if err := func() error {
s.ViewMode.Reset()
if err := s.ViewMode.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"viewMode\"")
}
case "kind":
if err := func() error {
s.Kind.Reset()
if err := s.Kind.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"kind\"")
}
case "groupId":
if err := func() error {
s.GroupId.Reset()
if err := s.GroupId.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"groupId\"")
}
case "isOwner":
if err := func() error {
s.IsOwner.Reset()
if err := s.IsOwner.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"isOwner\"")
}
case "closed":
if err := func() error {
s.Closed.Reset()
if err := s.Closed.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"closed\"")
}
case "modifiedTime":
if err := func() error {
s.ModifiedTime.Reset()
if err := s.ModifiedTime.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"modifiedTime\"")
}
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 *ProjectData) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *ProjectData) encodeFields(e *jx.Encoder) {
{
if s.Project.Set {
e.FieldStart("project")
s.Project.Encode(e)
}
}
{
if s.Tasks.Set {
e.FieldStart("tasks")
s.Tasks.Encode(e)
}
}
{
if s.Columns.Set {
e.FieldStart("columns")
s.Columns.Encode(e)
}
}
}
var jsonFieldsNameOfProjectData = [3]string{
0: "project",
1: "tasks",
2: "columns",
}
// Decode decodes ProjectData from json.
func (s *ProjectData) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode ProjectData to nil")
}
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "project":
if err := func() error {
s.Project.Reset()
if err := s.Project.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"project\"")
}
case "tasks":
if err := func() error {
s.Tasks.Reset()
if err := s.Tasks.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"tasks\"")
}
case "columns":
if err := func() error {
s.Columns.Reset()
if err := s.Columns.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"columns\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode ProjectData")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *ProjectData) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *ProjectData) 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.Title.Set {
e.FieldStart("title")
s.Title.Encode(e)
}
}
{
if s.Content.Set {
e.FieldStart("content")
s.Content.Encode(e)
}
}
{
if s.Desc.Set {
e.FieldStart("desc")
s.Desc.Encode(e)
}
}
{
if s.IsAllDay.Set {
e.FieldStart("isAllDay")
s.IsAllDay.Encode(e)
}
}
{
if s.StartDate.Set {
e.FieldStart("startDate")
s.StartDate.Encode(e)
}
}
{
if s.DueDate.Set {
e.FieldStart("dueDate")
s.DueDate.Encode(e)
}
}
{
if s.TimeZone.Set {
e.FieldStart("timeZone")
s.TimeZone.Encode(e)
}
}
{
if s.Reminders.Set {
e.FieldStart("reminders")
s.Reminders.Encode(e)
}
}
{
if s.RepeatFlag.Set {
e.FieldStart("repeatFlag")
s.RepeatFlag.Encode(e)
}
}
{
if s.Priority.Set {
e.FieldStart("priority")
s.Priority.Encode(e)
}
}
{
if s.Status.Set {
e.FieldStart("status")
s.Status.Encode(e)
}
}
{
if s.SortOrder.Set {
e.FieldStart("sortOrder")
s.SortOrder.Encode(e)
}
}
{
if s.Items.Set {
e.FieldStart("items")
s.Items.Encode(e)
}
}
{
if s.Tags.Set {
e.FieldStart("tags")
s.Tags.Encode(e)
}
}
{
if s.CompletedTime.Set {
e.FieldStart("completedTime")
s.CompletedTime.Encode(e)
}
}
{
if s.ModifiedTime.Set {
e.FieldStart("modifiedTime")
s.ModifiedTime.Encode(e)
}
}
{
if s.CreatedTime.Set {
e.FieldStart("createdTime")
s.CreatedTime.Encode(e)
}
}
{
if s.Kind.Set {
e.FieldStart("kind")
s.Kind.Encode(e)
}
}
}
var jsonFieldsNameOfTask = [20]string{
0: "id",
1: "projectId",
2: "title",
3: "content",
4: "desc",
5: "isAllDay",
6: "startDate",
7: "dueDate",
8: "timeZone",
9: "reminders",
10: "repeatFlag",
11: "priority",
12: "status",
13: "sortOrder",
14: "items",
15: "tags",
16: "completedTime",
17: "modifiedTime",
18: "createdTime",
19: "kind",
}
// 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 "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 "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 "desc":
if err := func() error {
s.Desc.Reset()
if err := s.Desc.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"desc\"")
}
case "isAllDay":
if err := func() error {
s.IsAllDay.Reset()
if err := s.IsAllDay.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"isAllDay\"")
}
case "startDate":
if err := func() error {
s.StartDate.Reset()
if err := s.StartDate.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"startDate\"")
}
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 "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 "reminders":
if err := func() error {
s.Reminders.Reset()
if err := s.Reminders.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"reminders\"")
}
case "repeatFlag":
if err := func() error {
s.RepeatFlag.Reset()
if err := s.RepeatFlag.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"repeatFlag\"")
}
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 "status":
if err := func() error {
s.Status.Reset()
if err := s.Status.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"status\"")
}
case "sortOrder":
if err := func() error {
s.SortOrder.Reset()
if err := s.SortOrder.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"sortOrder\"")
}
case "items":
if err := func() error {
s.Items.Reset()
if err := s.Items.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"items\"")
}
case "tags":
if err := func() error {
s.Tags.Reset()
if err := s.Tags.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"tags\"")
}
case "completedTime":
if err := func() error {
s.CompletedTime.Reset()
if err := s.CompletedTime.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"completedTime\"")
}
case "modifiedTime":
if err := func() error {
s.ModifiedTime.Reset()
if err := s.ModifiedTime.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"modifiedTime\"")
}
case "createdTime":
if err := func() error {
s.CreatedTime.Reset()
if err := s.CreatedTime.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"createdTime\"")
}
case "kind":
if err := func() error {
s.Kind.Reset()
if err := s.Kind.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"kind\"")
}
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 *UpdateProjectReq) Encode(e *jx.Encoder) {
e.ObjStart()
s.encodeFields(e)
e.ObjEnd()
}
// encodeFields encodes fields.
func (s *UpdateProjectReq) 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)
}
}
{
if s.ViewMode.Set {
e.FieldStart("viewMode")
s.ViewMode.Encode(e)
}
}
{
if s.Kind.Set {
e.FieldStart("kind")
s.Kind.Encode(e)
}
}
}
var jsonFieldsNameOfUpdateProjectReq = [4]string{
0: "name",
1: "color",
2: "viewMode",
3: "kind",
}
// Decode decodes UpdateProjectReq from json.
func (s *UpdateProjectReq) Decode(d *jx.Decoder) error {
if s == nil {
return errors.New("invalid: unable to decode UpdateProjectReq 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\"")
}
case "viewMode":
if err := func() error {
s.ViewMode.Reset()
if err := s.ViewMode.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"viewMode\"")
}
case "kind":
if err := func() error {
s.Kind.Reset()
if err := s.Kind.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"kind\"")
}
default:
return d.Skip()
}
return nil
}); err != nil {
return errors.Wrap(err, "decode UpdateProjectReq")
}
return nil
}
// MarshalJSON implements stdjson.Marshaler.
func (s *UpdateProjectReq) MarshalJSON() ([]byte, error) {
e := jx.Encoder{}
s.Encode(&e)
return e.Bytes(), nil
}
// UnmarshalJSON implements stdjson.Unmarshaler.
func (s *UpdateProjectReq) 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) {
{
e.FieldStart("id")
e.Str(s.ID)
}
{
e.FieldStart("projectId")
e.Str(s.ProjectId)
}
{
if s.Title.Set {
e.FieldStart("title")
s.Title.Encode(e)
}
}
{
if s.Content.Set {
e.FieldStart("content")
s.Content.Encode(e)
}
}
{
if s.Desc.Set {
e.FieldStart("desc")
s.Desc.Encode(e)
}
}
{
if s.IsAllDay.Set {
e.FieldStart("isAllDay")
s.IsAllDay.Encode(e)
}
}
{
if s.StartDate.Set {
e.FieldStart("startDate")
s.StartDate.Encode(e)
}
}
{
if s.DueDate.Set {
e.FieldStart("dueDate")
s.DueDate.Encode(e)
}
}
{
if s.TimeZone.Set {
e.FieldStart("timeZone")
s.TimeZone.Encode(e)
}
}
{
if s.Reminders != nil {
e.FieldStart("reminders")
e.ArrStart()
for _, elem := range s.Reminders {
e.Str(elem)
}
e.ArrEnd()
}
}
{
if s.RepeatFlag.Set {
e.FieldStart("repeatFlag")
s.RepeatFlag.Encode(e)
}
}
{
if s.Priority.Set {
e.FieldStart("priority")
s.Priority.Encode(e)
}
}
{
if s.SortOrder.Set {
e.FieldStart("sortOrder")
s.SortOrder.Encode(e)
}
}
{
if s.Items != nil {
e.FieldStart("items")
e.ArrStart()
for _, elem := range s.Items {
elem.Encode(e)
}
e.ArrEnd()
}
}
}
var jsonFieldsNameOfUpdateTaskReq = [14]string{
0: "id",
1: "projectId",
2: "title",
3: "content",
4: "desc",
5: "isAllDay",
6: "startDate",
7: "dueDate",
8: "timeZone",
9: "reminders",
10: "repeatFlag",
11: "priority",
12: "sortOrder",
13: "items",
}
// 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")
}
var requiredBitSet [2]uint8
if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error {
switch string(k) {
case "id":
requiredBitSet[0] |= 1 << 0
if err := func() error {
v, err := d.Str()
s.ID = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"id\"")
}
case "projectId":
requiredBitSet[0] |= 1 << 1
if err := func() error {
v, err := d.Str()
s.ProjectId = string(v)
if err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"projectId\"")
}
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 "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 "desc":
if err := func() error {
s.Desc.Reset()
if err := s.Desc.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"desc\"")
}
case "isAllDay":
if err := func() error {
s.IsAllDay.Reset()
if err := s.IsAllDay.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"isAllDay\"")
}
case "startDate":
if err := func() error {
s.StartDate.Reset()
if err := s.StartDate.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"startDate\"")
}
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 "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 "reminders":
if err := func() error {
s.Reminders = 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.Reminders = append(s.Reminders, elem)
return nil
}); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"reminders\"")
}
case "repeatFlag":
if err := func() error {
s.RepeatFlag.Reset()
if err := s.RepeatFlag.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"repeatFlag\"")
}
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 "sortOrder":
if err := func() error {
s.SortOrder.Reset()
if err := s.SortOrder.Decode(d); err != nil {
return err
}
return nil
}(); err != nil {
return errors.Wrap(err, "decode field \"sortOrder\"")
}
case "items":
if err := func() error {
s.Items = make([]ChecklistItem, 0)
if err := d.Arr(func(d *jx.Decoder) error {
var elem ChecklistItem
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 UpdateTaskReq")
}
// 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(jsonFieldsNameOfUpdateTaskReq) {
name = jsonFieldsNameOfUpdateTaskReq[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 *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)
}
