You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
394 lines
8.3 KiB
394 lines
8.3 KiB
// Auto-generated to Go types using avdl-compiler v1.4.6 (https://github.com/keybase/node-avdl-compiler) |
|
// Input file: ../../../../../../client/protocol/avdl/gregor1/common.avdl |
|
|
|
package gregor1 |
|
|
|
type TimeOrOffset struct { |
|
Time_ Time `codec:"time" json:"time"` |
|
Offset_ DurationMsec `codec:"offset" json:"offset"` |
|
} |
|
|
|
func (o TimeOrOffset) DeepCopy() TimeOrOffset { |
|
return TimeOrOffset{ |
|
Time_: o.Time_.DeepCopy(), |
|
Offset_: o.Offset_.DeepCopy(), |
|
} |
|
} |
|
|
|
type Metadata struct { |
|
Uid_ UID `codec:"uid" json:"uid"` |
|
MsgID_ MsgID `codec:"msgID" json:"msgID"` |
|
Ctime_ Time `codec:"ctime" json:"ctime"` |
|
DeviceID_ DeviceID `codec:"deviceID" json:"deviceID"` |
|
InBandMsgType_ int `codec:"inBandMsgType" json:"inBandMsgType"` |
|
} |
|
|
|
func (o Metadata) DeepCopy() Metadata { |
|
return Metadata{ |
|
Uid_: o.Uid_.DeepCopy(), |
|
MsgID_: o.MsgID_.DeepCopy(), |
|
Ctime_: o.Ctime_.DeepCopy(), |
|
DeviceID_: o.DeviceID_.DeepCopy(), |
|
InBandMsgType_: o.InBandMsgType_, |
|
} |
|
} |
|
|
|
type InBandMessage struct { |
|
StateUpdate_ *StateUpdateMessage `codec:"stateUpdate,omitempty" json:"stateUpdate,omitempty"` |
|
StateSync_ *StateSyncMessage `codec:"stateSync,omitempty" json:"stateSync,omitempty"` |
|
} |
|
|
|
func (o InBandMessage) DeepCopy() InBandMessage { |
|
return InBandMessage{ |
|
StateUpdate_: (func(x *StateUpdateMessage) *StateUpdateMessage { |
|
if x == nil { |
|
return nil |
|
} |
|
tmp := (*x).DeepCopy() |
|
return &tmp |
|
})(o.StateUpdate_), |
|
StateSync_: (func(x *StateSyncMessage) *StateSyncMessage { |
|
if x == nil { |
|
return nil |
|
} |
|
tmp := (*x).DeepCopy() |
|
return &tmp |
|
})(o.StateSync_), |
|
} |
|
} |
|
|
|
type State struct { |
|
Items_ []ItemAndMetadata `codec:"items" json:"items"` |
|
} |
|
|
|
func (o State) DeepCopy() State { |
|
return State{ |
|
Items_: (func(x []ItemAndMetadata) []ItemAndMetadata { |
|
if x == nil { |
|
return nil |
|
} |
|
ret := make([]ItemAndMetadata, len(x)) |
|
for i, v := range x { |
|
vCopy := v.DeepCopy() |
|
ret[i] = vCopy |
|
} |
|
return ret |
|
})(o.Items_), |
|
} |
|
} |
|
|
|
type StateUpdateMessage struct { |
|
Md_ Metadata `codec:"md" json:"md"` |
|
Creation_ *Item `codec:"creation,omitempty" json:"creation,omitempty"` |
|
Dismissal_ *Dismissal `codec:"dismissal,omitempty" json:"dismissal,omitempty"` |
|
} |
|
|
|
func (o StateUpdateMessage) DeepCopy() StateUpdateMessage { |
|
return StateUpdateMessage{ |
|
Md_: o.Md_.DeepCopy(), |
|
Creation_: (func(x *Item) *Item { |
|
if x == nil { |
|
return nil |
|
} |
|
tmp := (*x).DeepCopy() |
|
return &tmp |
|
})(o.Creation_), |
|
Dismissal_: (func(x *Dismissal) *Dismissal { |
|
if x == nil { |
|
return nil |
|
} |
|
tmp := (*x).DeepCopy() |
|
return &tmp |
|
})(o.Dismissal_), |
|
} |
|
} |
|
|
|
type StateSyncMessage struct { |
|
Md_ Metadata `codec:"md" json:"md"` |
|
} |
|
|
|
func (o StateSyncMessage) DeepCopy() StateSyncMessage { |
|
return StateSyncMessage{ |
|
Md_: o.Md_.DeepCopy(), |
|
} |
|
} |
|
|
|
type MsgRange struct { |
|
EndTime_ TimeOrOffset `codec:"endTime" json:"endTime"` |
|
Category_ Category `codec:"category" json:"category"` |
|
SkipMsgIDs_ []MsgID `codec:"skipMsgIDs" json:"skipMsgIDs"` |
|
} |
|
|
|
func (o MsgRange) DeepCopy() MsgRange { |
|
return MsgRange{ |
|
EndTime_: o.EndTime_.DeepCopy(), |
|
Category_: o.Category_.DeepCopy(), |
|
SkipMsgIDs_: (func(x []MsgID) []MsgID { |
|
if x == nil { |
|
return nil |
|
} |
|
ret := make([]MsgID, len(x)) |
|
for i, v := range x { |
|
vCopy := v.DeepCopy() |
|
ret[i] = vCopy |
|
} |
|
return ret |
|
})(o.SkipMsgIDs_), |
|
} |
|
} |
|
|
|
type Dismissal struct { |
|
MsgIDs_ []MsgID `codec:"msgIDs" json:"msgIDs"` |
|
Ranges_ []MsgRange `codec:"ranges" json:"ranges"` |
|
} |
|
|
|
func (o Dismissal) DeepCopy() Dismissal { |
|
return Dismissal{ |
|
MsgIDs_: (func(x []MsgID) []MsgID { |
|
if x == nil { |
|
return nil |
|
} |
|
ret := make([]MsgID, len(x)) |
|
for i, v := range x { |
|
vCopy := v.DeepCopy() |
|
ret[i] = vCopy |
|
} |
|
return ret |
|
})(o.MsgIDs_), |
|
Ranges_: (func(x []MsgRange) []MsgRange { |
|
if x == nil { |
|
return nil |
|
} |
|
ret := make([]MsgRange, len(x)) |
|
for i, v := range x { |
|
vCopy := v.DeepCopy() |
|
ret[i] = vCopy |
|
} |
|
return ret |
|
})(o.Ranges_), |
|
} |
|
} |
|
|
|
type Item struct { |
|
Category_ Category `codec:"category" json:"category"` |
|
Dtime_ TimeOrOffset `codec:"dtime" json:"dtime"` |
|
RemindTimes_ []TimeOrOffset `codec:"remindTimes" json:"remindTimes"` |
|
Body_ Body `codec:"body" json:"body"` |
|
} |
|
|
|
func (o Item) DeepCopy() Item { |
|
return Item{ |
|
Category_: o.Category_.DeepCopy(), |
|
Dtime_: o.Dtime_.DeepCopy(), |
|
RemindTimes_: (func(x []TimeOrOffset) []TimeOrOffset { |
|
if x == nil { |
|
return nil |
|
} |
|
ret := make([]TimeOrOffset, len(x)) |
|
for i, v := range x { |
|
vCopy := v.DeepCopy() |
|
ret[i] = vCopy |
|
} |
|
return ret |
|
})(o.RemindTimes_), |
|
Body_: o.Body_.DeepCopy(), |
|
} |
|
} |
|
|
|
type ItemAndMetadata struct { |
|
Md_ *Metadata `codec:"md,omitempty" json:"md,omitempty"` |
|
Item_ *Item `codec:"item,omitempty" json:"item,omitempty"` |
|
} |
|
|
|
func (o ItemAndMetadata) DeepCopy() ItemAndMetadata { |
|
return ItemAndMetadata{ |
|
Md_: (func(x *Metadata) *Metadata { |
|
if x == nil { |
|
return nil |
|
} |
|
tmp := (*x).DeepCopy() |
|
return &tmp |
|
})(o.Md_), |
|
Item_: (func(x *Item) *Item { |
|
if x == nil { |
|
return nil |
|
} |
|
tmp := (*x).DeepCopy() |
|
return &tmp |
|
})(o.Item_), |
|
} |
|
} |
|
|
|
type Reminder struct { |
|
Item_ ItemAndMetadata `codec:"item" json:"item"` |
|
Seqno_ int `codec:"seqno" json:"seqno"` |
|
RemindTime_ Time `codec:"remindTime" json:"remindTime"` |
|
} |
|
|
|
func (o Reminder) DeepCopy() Reminder { |
|
return Reminder{ |
|
Item_: o.Item_.DeepCopy(), |
|
Seqno_: o.Seqno_, |
|
RemindTime_: o.RemindTime_.DeepCopy(), |
|
} |
|
} |
|
|
|
type ReminderID struct { |
|
Uid_ UID `codec:"uid" json:"uid"` |
|
MsgID_ MsgID `codec:"msgID" json:"msgID"` |
|
Seqno_ int `codec:"seqno" json:"seqno"` |
|
} |
|
|
|
func (o ReminderID) DeepCopy() ReminderID { |
|
return ReminderID{ |
|
Uid_: o.Uid_.DeepCopy(), |
|
MsgID_: o.MsgID_.DeepCopy(), |
|
Seqno_: o.Seqno_, |
|
} |
|
} |
|
|
|
type OutOfBandMessage struct { |
|
Uid_ UID `codec:"uid" json:"uid"` |
|
System_ System `codec:"system" json:"system"` |
|
Body_ Body `codec:"body" json:"body"` |
|
} |
|
|
|
func (o OutOfBandMessage) DeepCopy() OutOfBandMessage { |
|
return OutOfBandMessage{ |
|
Uid_: o.Uid_.DeepCopy(), |
|
System_: o.System_.DeepCopy(), |
|
Body_: o.Body_.DeepCopy(), |
|
} |
|
} |
|
|
|
type ReminderSet struct { |
|
Reminders_ []Reminder `codec:"reminders" json:"reminders"` |
|
MoreRemindersReady_ bool `codec:"moreRemindersReady" json:"moreRemindersReady"` |
|
} |
|
|
|
func (o ReminderSet) DeepCopy() ReminderSet { |
|
return ReminderSet{ |
|
Reminders_: (func(x []Reminder) []Reminder { |
|
if x == nil { |
|
return nil |
|
} |
|
ret := make([]Reminder, len(x)) |
|
for i, v := range x { |
|
vCopy := v.DeepCopy() |
|
ret[i] = vCopy |
|
} |
|
return ret |
|
})(o.Reminders_), |
|
MoreRemindersReady_: o.MoreRemindersReady_, |
|
} |
|
} |
|
|
|
type Message struct { |
|
Oobm_ *OutOfBandMessage `codec:"oobm,omitempty" json:"oobm,omitempty"` |
|
Ibm_ *InBandMessage `codec:"ibm,omitempty" json:"ibm,omitempty"` |
|
} |
|
|
|
func (o Message) DeepCopy() Message { |
|
return Message{ |
|
Oobm_: (func(x *OutOfBandMessage) *OutOfBandMessage { |
|
if x == nil { |
|
return nil |
|
} |
|
tmp := (*x).DeepCopy() |
|
return &tmp |
|
})(o.Oobm_), |
|
Ibm_: (func(x *InBandMessage) *InBandMessage { |
|
if x == nil { |
|
return nil |
|
} |
|
tmp := (*x).DeepCopy() |
|
return &tmp |
|
})(o.Ibm_), |
|
} |
|
} |
|
|
|
type DurationMsec int64 |
|
|
|
func (o DurationMsec) DeepCopy() DurationMsec { |
|
return o |
|
} |
|
|
|
type DurationSec int64 |
|
|
|
func (o DurationSec) DeepCopy() DurationSec { |
|
return o |
|
} |
|
|
|
type Category string |
|
|
|
func (o Category) DeepCopy() Category { |
|
return o |
|
} |
|
|
|
type System string |
|
|
|
func (o System) DeepCopy() System { |
|
return o |
|
} |
|
|
|
type UID []byte |
|
|
|
func (o UID) DeepCopy() UID { |
|
return (func(x []byte) []byte { |
|
if x == nil { |
|
return nil |
|
} |
|
return append([]byte{}, x...) |
|
})(o) |
|
} |
|
|
|
type MsgID []byte |
|
|
|
func (o MsgID) DeepCopy() MsgID { |
|
return (func(x []byte) []byte { |
|
if x == nil { |
|
return nil |
|
} |
|
return append([]byte{}, x...) |
|
})(o) |
|
} |
|
|
|
type DeviceID []byte |
|
|
|
func (o DeviceID) DeepCopy() DeviceID { |
|
return (func(x []byte) []byte { |
|
if x == nil { |
|
return nil |
|
} |
|
return append([]byte{}, x...) |
|
})(o) |
|
} |
|
|
|
type Body []byte |
|
|
|
func (o Body) DeepCopy() Body { |
|
return (func(x []byte) []byte { |
|
if x == nil { |
|
return nil |
|
} |
|
return append([]byte{}, x...) |
|
})(o) |
|
} |
|
|
|
type Time int64 |
|
|
|
func (o Time) DeepCopy() Time { |
|
return o |
|
} |
|
|
|
type SessionID string |
|
|
|
func (o SessionID) DeepCopy() SessionID { |
|
return o |
|
} |
|
|
|
type SessionToken string |
|
|
|
func (o SessionToken) DeepCopy() SessionToken { |
|
return o |
|
}
|
|
|