4901 lines
121 KiB
Go
4901 lines
121 KiB
Go
// Code generated by protoc-gen-gogo. DO NOT EDIT.
|
|
// source: pkg/acl/aclchanges/aclpb/protos/aclchanges.proto
|
|
|
|
package aclpb
|
|
|
|
import (
|
|
fmt "fmt"
|
|
proto "github.com/gogo/protobuf/proto"
|
|
io "io"
|
|
math "math"
|
|
math_bits "math/bits"
|
|
)
|
|
|
|
// Reference imports to suppress errors if they are not otherwise used.
|
|
var _ = proto.Marshal
|
|
var _ = fmt.Errorf
|
|
var _ = math.Inf
|
|
|
|
// This is a compile-time assertion to ensure that this generated file
|
|
// is compatible with the proto package it is being compiled against.
|
|
// A compilation error at this line likely means your copy of the
|
|
// proto package needs to be updated.
|
|
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
|
|
|
|
type ACLChange_UserPermissions int32
|
|
|
|
const (
|
|
ACLChange_Admin ACLChange_UserPermissions = 0
|
|
ACLChange_Writer ACLChange_UserPermissions = 1
|
|
ACLChange_Reader ACLChange_UserPermissions = 2
|
|
ACLChange_Removed ACLChange_UserPermissions = 3
|
|
)
|
|
|
|
var ACLChange_UserPermissions_name = map[int32]string{
|
|
0: "Admin",
|
|
1: "Writer",
|
|
2: "Reader",
|
|
3: "Removed",
|
|
}
|
|
|
|
var ACLChange_UserPermissions_value = map[string]int32{
|
|
"Admin": 0,
|
|
"Writer": 1,
|
|
"Reader": 2,
|
|
"Removed": 3,
|
|
}
|
|
|
|
func (x ACLChange_UserPermissions) String() string {
|
|
return proto.EnumName(ACLChange_UserPermissions_name, int32(x))
|
|
}
|
|
|
|
func (ACLChange_UserPermissions) EnumDescriptor() ([]byte, []int) {
|
|
return fileDescriptor_37a022c841a51877, []int{1, 0}
|
|
}
|
|
|
|
type RawChange struct {
|
|
Payload []byte `protobuf:"bytes,1,opt,name=payload,proto3" json:"payload,omitempty"`
|
|
Signature []byte `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty"`
|
|
Id string `protobuf:"bytes,3,opt,name=id,proto3" json:"id,omitempty"`
|
|
}
|
|
|
|
func (m *RawChange) Reset() { *m = RawChange{} }
|
|
func (m *RawChange) String() string { return proto.CompactTextString(m) }
|
|
func (*RawChange) ProtoMessage() {}
|
|
func (*RawChange) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_37a022c841a51877, []int{0}
|
|
}
|
|
func (m *RawChange) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *RawChange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_RawChange.Marshal(b, m, deterministic)
|
|
} else {
|
|
b = b[:cap(b)]
|
|
n, err := m.MarshalToSizedBuffer(b)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return b[:n], nil
|
|
}
|
|
}
|
|
func (m *RawChange) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_RawChange.Merge(m, src)
|
|
}
|
|
func (m *RawChange) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *RawChange) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_RawChange.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_RawChange proto.InternalMessageInfo
|
|
|
|
func (m *RawChange) GetPayload() []byte {
|
|
if m != nil {
|
|
return m.Payload
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *RawChange) GetSignature() []byte {
|
|
if m != nil {
|
|
return m.Signature
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *RawChange) GetId() string {
|
|
if m != nil {
|
|
return m.Id
|
|
}
|
|
return ""
|
|
}
|
|
|
|
// the element of change tree used to store and internal apply smartBlock history
|
|
type ACLChange struct {
|
|
TreeHeadIds []string `protobuf:"bytes,1,rep,name=treeHeadIds,proto3" json:"treeHeadIds,omitempty"`
|
|
AclHeadIds []string `protobuf:"bytes,2,rep,name=aclHeadIds,proto3" json:"aclHeadIds,omitempty"`
|
|
SnapshotBaseId string `protobuf:"bytes,3,opt,name=snapshotBaseId,proto3" json:"snapshotBaseId,omitempty"`
|
|
AclData *ACLChange_ACLData `protobuf:"bytes,4,opt,name=aclData,proto3" json:"aclData,omitempty"`
|
|
// the data is encoded with read key and should be read in ChangesData format
|
|
ChangesData []byte `protobuf:"bytes,5,opt,name=changesData,proto3" json:"changesData,omitempty"`
|
|
CurrentReadKeyHash uint64 `protobuf:"varint,6,opt,name=currentReadKeyHash,proto3" json:"currentReadKeyHash,omitempty"`
|
|
Timestamp int64 `protobuf:"varint,7,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
|
|
Identity string `protobuf:"bytes,8,opt,name=identity,proto3" json:"identity,omitempty"`
|
|
}
|
|
|
|
func (m *ACLChange) Reset() { *m = ACLChange{} }
|
|
func (m *ACLChange) String() string { return proto.CompactTextString(m) }
|
|
func (*ACLChange) ProtoMessage() {}
|
|
func (*ACLChange) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_37a022c841a51877, []int{1}
|
|
}
|
|
func (m *ACLChange) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *ACLChange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_ACLChange.Marshal(b, m, deterministic)
|
|
} else {
|
|
b = b[:cap(b)]
|
|
n, err := m.MarshalToSizedBuffer(b)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return b[:n], nil
|
|
}
|
|
}
|
|
func (m *ACLChange) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_ACLChange.Merge(m, src)
|
|
}
|
|
func (m *ACLChange) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *ACLChange) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_ACLChange.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_ACLChange proto.InternalMessageInfo
|
|
|
|
func (m *ACLChange) GetTreeHeadIds() []string {
|
|
if m != nil {
|
|
return m.TreeHeadIds
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ACLChange) GetAclHeadIds() []string {
|
|
if m != nil {
|
|
return m.AclHeadIds
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ACLChange) GetSnapshotBaseId() string {
|
|
if m != nil {
|
|
return m.SnapshotBaseId
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *ACLChange) GetAclData() *ACLChange_ACLData {
|
|
if m != nil {
|
|
return m.AclData
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ACLChange) GetChangesData() []byte {
|
|
if m != nil {
|
|
return m.ChangesData
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ACLChange) GetCurrentReadKeyHash() uint64 {
|
|
if m != nil {
|
|
return m.CurrentReadKeyHash
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *ACLChange) GetTimestamp() int64 {
|
|
if m != nil {
|
|
return m.Timestamp
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (m *ACLChange) GetIdentity() string {
|
|
if m != nil {
|
|
return m.Identity
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type ACLChange_ACLContentValue struct {
|
|
// Types that are valid to be assigned to Value:
|
|
//
|
|
// *ACLChange_ACLContent_Value_UserAdd
|
|
// *ACLChange_ACLContent_Value_UserRemove
|
|
// *ACLChange_ACLContent_Value_UserPermissionChange
|
|
// *ACLChange_ACLContent_Value_UserInvite
|
|
// *ACLChange_ACLContent_Value_UserJoin
|
|
// *ACLChange_ACLContent_Value_UserConfirm
|
|
Value isACLChange_ACLContent_Value_Value `protobuf_oneof:"value"`
|
|
}
|
|
|
|
func (m *ACLChange_ACLContentValue) Reset() { *m = ACLChange_ACLContentValue{} }
|
|
func (m *ACLChange_ACLContentValue) String() string { return proto.CompactTextString(m) }
|
|
func (*ACLChange_ACLContentValue) ProtoMessage() {}
|
|
func (*ACLChange_ACLContentValue) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_37a022c841a51877, []int{1, 0}
|
|
}
|
|
func (m *ACLChange_ACLContentValue) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *ACLChange_ACLContentValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_ACLChange_ACLContentValue.Marshal(b, m, deterministic)
|
|
} else {
|
|
b = b[:cap(b)]
|
|
n, err := m.MarshalToSizedBuffer(b)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return b[:n], nil
|
|
}
|
|
}
|
|
func (m *ACLChange_ACLContentValue) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_ACLChange_ACLContentValue.Merge(m, src)
|
|
}
|
|
func (m *ACLChange_ACLContentValue) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *ACLChange_ACLContentValue) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_ACLChange_ACLContentValue.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_ACLChange_ACLContentValue proto.InternalMessageInfo
|
|
|
|
type isACLChange_ACLContent_Value_Value interface {
|
|
isACLChange_ACLContent_Value_Value()
|
|
MarshalTo([]byte) (int, error)
|
|
Size() int
|
|
}
|
|
|
|
type ACLChange_ACLContent_Value_UserAdd struct {
|
|
UserAdd *ACLChange_UserAdd `protobuf:"bytes,1,opt,name=userAdd,proto3,oneof" json:"userAdd,omitempty"`
|
|
}
|
|
type ACLChange_ACLContent_Value_UserRemove struct {
|
|
UserRemove *ACLChange_UserRemove `protobuf:"bytes,2,opt,name=userRemove,proto3,oneof" json:"userRemove,omitempty"`
|
|
}
|
|
type ACLChange_ACLContent_Value_UserPermissionChange struct {
|
|
UserPermissionChange *ACLChange_UserPermissionChange `protobuf:"bytes,3,opt,name=userPermissionChange,proto3,oneof" json:"userPermissionChange,omitempty"`
|
|
}
|
|
type ACLChange_ACLContent_Value_UserInvite struct {
|
|
UserInvite *ACLChange_UserInvite `protobuf:"bytes,4,opt,name=userInvite,proto3,oneof" json:"userInvite,omitempty"`
|
|
}
|
|
type ACLChange_ACLContent_Value_UserJoin struct {
|
|
UserJoin *ACLChange_UserJoin `protobuf:"bytes,5,opt,name=userJoin,proto3,oneof" json:"userJoin,omitempty"`
|
|
}
|
|
type ACLChange_ACLContent_Value_UserConfirm struct {
|
|
UserConfirm *ACLChange_UserConfirm `protobuf:"bytes,6,opt,name=userConfirm,proto3,oneof" json:"userConfirm,omitempty"`
|
|
}
|
|
|
|
func (*ACLChange_ACLContent_Value_UserAdd) isACLChange_ACLContent_Value_Value() {}
|
|
func (*ACLChange_ACLContent_Value_UserRemove) isACLChange_ACLContent_Value_Value() {}
|
|
func (*ACLChange_ACLContent_Value_UserPermissionChange) isACLChange_ACLContent_Value_Value() {}
|
|
func (*ACLChange_ACLContent_Value_UserInvite) isACLChange_ACLContent_Value_Value() {}
|
|
func (*ACLChange_ACLContent_Value_UserJoin) isACLChange_ACLContent_Value_Value() {}
|
|
func (*ACLChange_ACLContent_Value_UserConfirm) isACLChange_ACLContent_Value_Value() {}
|
|
|
|
func (m *ACLChange_ACLContentValue) GetValue() isACLChange_ACLContent_Value_Value {
|
|
if m != nil {
|
|
return m.Value
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ACLChange_ACLContentValue) GetUserAdd() *ACLChange_UserAdd {
|
|
if x, ok := m.GetValue().(*ACLChange_ACLContent_Value_UserAdd); ok {
|
|
return x.UserAdd
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ACLChange_ACLContentValue) GetUserRemove() *ACLChange_UserRemove {
|
|
if x, ok := m.GetValue().(*ACLChange_ACLContent_Value_UserRemove); ok {
|
|
return x.UserRemove
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ACLChange_ACLContentValue) GetUserPermissionChange() *ACLChange_UserPermissionChange {
|
|
if x, ok := m.GetValue().(*ACLChange_ACLContent_Value_UserPermissionChange); ok {
|
|
return x.UserPermissionChange
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ACLChange_ACLContentValue) GetUserInvite() *ACLChange_UserInvite {
|
|
if x, ok := m.GetValue().(*ACLChange_ACLContent_Value_UserInvite); ok {
|
|
return x.UserInvite
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ACLChange_ACLContentValue) GetUserJoin() *ACLChange_UserJoin {
|
|
if x, ok := m.GetValue().(*ACLChange_ACLContent_Value_UserJoin); ok {
|
|
return x.UserJoin
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ACLChange_ACLContentValue) GetUserConfirm() *ACLChange_UserConfirm {
|
|
if x, ok := m.GetValue().(*ACLChange_ACLContent_Value_UserConfirm); ok {
|
|
return x.UserConfirm
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// XXX_OneofWrappers is for the internal use of the proto package.
|
|
func (*ACLChange_ACLContentValue) XXX_OneofWrappers() []interface{} {
|
|
return []interface{}{
|
|
(*ACLChange_ACLContent_Value_UserAdd)(nil),
|
|
(*ACLChange_ACLContent_Value_UserRemove)(nil),
|
|
(*ACLChange_ACLContent_Value_UserPermissionChange)(nil),
|
|
(*ACLChange_ACLContent_Value_UserInvite)(nil),
|
|
(*ACLChange_ACLContent_Value_UserJoin)(nil),
|
|
(*ACLChange_ACLContent_Value_UserConfirm)(nil),
|
|
}
|
|
}
|
|
|
|
type ACLChange_ACLData struct {
|
|
AclSnapshot *ACLChange_ACLSnapshot `protobuf:"bytes,1,opt,name=aclSnapshot,proto3" json:"aclSnapshot,omitempty"`
|
|
AclContent []*ACLChange_ACLContentValue `protobuf:"bytes,2,rep,name=aclContent,proto3" json:"aclContent,omitempty"`
|
|
}
|
|
|
|
func (m *ACLChange_ACLData) Reset() { *m = ACLChange_ACLData{} }
|
|
func (m *ACLChange_ACLData) String() string { return proto.CompactTextString(m) }
|
|
func (*ACLChange_ACLData) ProtoMessage() {}
|
|
func (*ACLChange_ACLData) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_37a022c841a51877, []int{1, 1}
|
|
}
|
|
func (m *ACLChange_ACLData) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *ACLChange_ACLData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_ACLChange_ACLData.Marshal(b, m, deterministic)
|
|
} else {
|
|
b = b[:cap(b)]
|
|
n, err := m.MarshalToSizedBuffer(b)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return b[:n], nil
|
|
}
|
|
}
|
|
func (m *ACLChange_ACLData) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_ACLChange_ACLData.Merge(m, src)
|
|
}
|
|
func (m *ACLChange_ACLData) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *ACLChange_ACLData) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_ACLChange_ACLData.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_ACLChange_ACLData proto.InternalMessageInfo
|
|
|
|
func (m *ACLChange_ACLData) GetAclSnapshot() *ACLChange_ACLSnapshot {
|
|
if m != nil {
|
|
return m.AclSnapshot
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ACLChange_ACLData) GetAclContent() []*ACLChange_ACLContentValue {
|
|
if m != nil {
|
|
return m.AclContent
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type ACLChange_ACLSnapshot struct {
|
|
// We don't need ACLState as a separate message now, because we simplified the snapshot model
|
|
AclState *ACLChange_ACLState `protobuf:"bytes,1,opt,name=aclState,proto3" json:"aclState,omitempty"`
|
|
}
|
|
|
|
func (m *ACLChange_ACLSnapshot) Reset() { *m = ACLChange_ACLSnapshot{} }
|
|
func (m *ACLChange_ACLSnapshot) String() string { return proto.CompactTextString(m) }
|
|
func (*ACLChange_ACLSnapshot) ProtoMessage() {}
|
|
func (*ACLChange_ACLSnapshot) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_37a022c841a51877, []int{1, 2}
|
|
}
|
|
func (m *ACLChange_ACLSnapshot) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *ACLChange_ACLSnapshot) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_ACLChange_ACLSnapshot.Marshal(b, m, deterministic)
|
|
} else {
|
|
b = b[:cap(b)]
|
|
n, err := m.MarshalToSizedBuffer(b)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return b[:n], nil
|
|
}
|
|
}
|
|
func (m *ACLChange_ACLSnapshot) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_ACLChange_ACLSnapshot.Merge(m, src)
|
|
}
|
|
func (m *ACLChange_ACLSnapshot) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *ACLChange_ACLSnapshot) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_ACLChange_ACLSnapshot.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_ACLChange_ACLSnapshot proto.InternalMessageInfo
|
|
|
|
func (m *ACLChange_ACLSnapshot) GetAclState() *ACLChange_ACLState {
|
|
if m != nil {
|
|
return m.AclState
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type ACLChange_ACLState struct {
|
|
ReadKeyHashes []uint64 `protobuf:"varint,1,rep,packed,name=readKeyHashes,proto3" json:"readKeyHashes,omitempty"`
|
|
UserStates []*ACLChange_UserState `protobuf:"bytes,2,rep,name=userStates,proto3" json:"userStates,omitempty"`
|
|
Invites map[string]*ACLChange_UserInvite `protobuf:"bytes,3,rep,name=invites,proto3" json:"invites,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
|
|
}
|
|
|
|
func (m *ACLChange_ACLState) Reset() { *m = ACLChange_ACLState{} }
|
|
func (m *ACLChange_ACLState) String() string { return proto.CompactTextString(m) }
|
|
func (*ACLChange_ACLState) ProtoMessage() {}
|
|
func (*ACLChange_ACLState) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_37a022c841a51877, []int{1, 3}
|
|
}
|
|
func (m *ACLChange_ACLState) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *ACLChange_ACLState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_ACLChange_ACLState.Marshal(b, m, deterministic)
|
|
} else {
|
|
b = b[:cap(b)]
|
|
n, err := m.MarshalToSizedBuffer(b)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return b[:n], nil
|
|
}
|
|
}
|
|
func (m *ACLChange_ACLState) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_ACLChange_ACLState.Merge(m, src)
|
|
}
|
|
func (m *ACLChange_ACLState) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *ACLChange_ACLState) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_ACLChange_ACLState.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_ACLChange_ACLState proto.InternalMessageInfo
|
|
|
|
func (m *ACLChange_ACLState) GetReadKeyHashes() []uint64 {
|
|
if m != nil {
|
|
return m.ReadKeyHashes
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ACLChange_ACLState) GetUserStates() []*ACLChange_UserState {
|
|
if m != nil {
|
|
return m.UserStates
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ACLChange_ACLState) GetInvites() map[string]*ACLChange_UserInvite {
|
|
if m != nil {
|
|
return m.Invites
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type ACLChange_UserState struct {
|
|
Identity string `protobuf:"bytes,1,opt,name=identity,proto3" json:"identity,omitempty"`
|
|
EncryptionKey []byte `protobuf:"bytes,2,opt,name=encryptionKey,proto3" json:"encryptionKey,omitempty"`
|
|
EncryptedReadKeys [][]byte `protobuf:"bytes,3,rep,name=encryptedReadKeys,proto3" json:"encryptedReadKeys,omitempty"`
|
|
Permissions ACLChange_UserPermissions `protobuf:"varint,4,opt,name=permissions,proto3,enum=acl.ACLChange_UserPermissions" json:"permissions,omitempty"`
|
|
IsConfirmed bool `protobuf:"varint,5,opt,name=IsConfirmed,proto3" json:"IsConfirmed,omitempty"`
|
|
}
|
|
|
|
func (m *ACLChange_UserState) Reset() { *m = ACLChange_UserState{} }
|
|
func (m *ACLChange_UserState) String() string { return proto.CompactTextString(m) }
|
|
func (*ACLChange_UserState) ProtoMessage() {}
|
|
func (*ACLChange_UserState) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_37a022c841a51877, []int{1, 4}
|
|
}
|
|
func (m *ACLChange_UserState) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *ACLChange_UserState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_ACLChange_UserState.Marshal(b, m, deterministic)
|
|
} else {
|
|
b = b[:cap(b)]
|
|
n, err := m.MarshalToSizedBuffer(b)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return b[:n], nil
|
|
}
|
|
}
|
|
func (m *ACLChange_UserState) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_ACLChange_UserState.Merge(m, src)
|
|
}
|
|
func (m *ACLChange_UserState) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *ACLChange_UserState) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_ACLChange_UserState.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_ACLChange_UserState proto.InternalMessageInfo
|
|
|
|
func (m *ACLChange_UserState) GetIdentity() string {
|
|
if m != nil {
|
|
return m.Identity
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *ACLChange_UserState) GetEncryptionKey() []byte {
|
|
if m != nil {
|
|
return m.EncryptionKey
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ACLChange_UserState) GetEncryptedReadKeys() [][]byte {
|
|
if m != nil {
|
|
return m.EncryptedReadKeys
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ACLChange_UserState) GetPermissions() ACLChange_UserPermissions {
|
|
if m != nil {
|
|
return m.Permissions
|
|
}
|
|
return ACLChange_Admin
|
|
}
|
|
|
|
func (m *ACLChange_UserState) GetIsConfirmed() bool {
|
|
if m != nil {
|
|
return m.IsConfirmed
|
|
}
|
|
return false
|
|
}
|
|
|
|
// we already know identity and encryptionKey
|
|
type ACLChange_UserAdd struct {
|
|
Identity string `protobuf:"bytes,1,opt,name=identity,proto3" json:"identity,omitempty"`
|
|
EncryptionKey []byte `protobuf:"bytes,2,opt,name=encryptionKey,proto3" json:"encryptionKey,omitempty"`
|
|
EncryptedReadKeys [][]byte `protobuf:"bytes,3,rep,name=encryptedReadKeys,proto3" json:"encryptedReadKeys,omitempty"`
|
|
Permissions ACLChange_UserPermissions `protobuf:"varint,4,opt,name=permissions,proto3,enum=acl.ACLChange_UserPermissions" json:"permissions,omitempty"`
|
|
}
|
|
|
|
func (m *ACLChange_UserAdd) Reset() { *m = ACLChange_UserAdd{} }
|
|
func (m *ACLChange_UserAdd) String() string { return proto.CompactTextString(m) }
|
|
func (*ACLChange_UserAdd) ProtoMessage() {}
|
|
func (*ACLChange_UserAdd) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_37a022c841a51877, []int{1, 5}
|
|
}
|
|
func (m *ACLChange_UserAdd) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *ACLChange_UserAdd) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_ACLChange_UserAdd.Marshal(b, m, deterministic)
|
|
} else {
|
|
b = b[:cap(b)]
|
|
n, err := m.MarshalToSizedBuffer(b)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return b[:n], nil
|
|
}
|
|
}
|
|
func (m *ACLChange_UserAdd) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_ACLChange_UserAdd.Merge(m, src)
|
|
}
|
|
func (m *ACLChange_UserAdd) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *ACLChange_UserAdd) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_ACLChange_UserAdd.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_ACLChange_UserAdd proto.InternalMessageInfo
|
|
|
|
func (m *ACLChange_UserAdd) GetIdentity() string {
|
|
if m != nil {
|
|
return m.Identity
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *ACLChange_UserAdd) GetEncryptionKey() []byte {
|
|
if m != nil {
|
|
return m.EncryptionKey
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ACLChange_UserAdd) GetEncryptedReadKeys() [][]byte {
|
|
if m != nil {
|
|
return m.EncryptedReadKeys
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ACLChange_UserAdd) GetPermissions() ACLChange_UserPermissions {
|
|
if m != nil {
|
|
return m.Permissions
|
|
}
|
|
return ACLChange_Admin
|
|
}
|
|
|
|
// TODO: this is not used as of now
|
|
type ACLChange_UserConfirm struct {
|
|
Identity string `protobuf:"bytes,1,opt,name=identity,proto3" json:"identity,omitempty"`
|
|
UserAddId string `protobuf:"bytes,2,opt,name=userAddId,proto3" json:"userAddId,omitempty"`
|
|
}
|
|
|
|
func (m *ACLChange_UserConfirm) Reset() { *m = ACLChange_UserConfirm{} }
|
|
func (m *ACLChange_UserConfirm) String() string { return proto.CompactTextString(m) }
|
|
func (*ACLChange_UserConfirm) ProtoMessage() {}
|
|
func (*ACLChange_UserConfirm) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_37a022c841a51877, []int{1, 6}
|
|
}
|
|
func (m *ACLChange_UserConfirm) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *ACLChange_UserConfirm) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_ACLChange_UserConfirm.Marshal(b, m, deterministic)
|
|
} else {
|
|
b = b[:cap(b)]
|
|
n, err := m.MarshalToSizedBuffer(b)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return b[:n], nil
|
|
}
|
|
}
|
|
func (m *ACLChange_UserConfirm) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_ACLChange_UserConfirm.Merge(m, src)
|
|
}
|
|
func (m *ACLChange_UserConfirm) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *ACLChange_UserConfirm) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_ACLChange_UserConfirm.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_ACLChange_UserConfirm proto.InternalMessageInfo
|
|
|
|
func (m *ACLChange_UserConfirm) GetIdentity() string {
|
|
if m != nil {
|
|
return m.Identity
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *ACLChange_UserConfirm) GetUserAddId() string {
|
|
if m != nil {
|
|
return m.UserAddId
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type ACLChange_UserInvite struct {
|
|
AcceptPublicKey []byte `protobuf:"bytes,1,opt,name=acceptPublicKey,proto3" json:"acceptPublicKey,omitempty"`
|
|
EncryptPublicKey []byte `protobuf:"bytes,2,opt,name=encryptPublicKey,proto3" json:"encryptPublicKey,omitempty"`
|
|
EncryptedReadKeys [][]byte `protobuf:"bytes,3,rep,name=encryptedReadKeys,proto3" json:"encryptedReadKeys,omitempty"`
|
|
Permissions ACLChange_UserPermissions `protobuf:"varint,4,opt,name=permissions,proto3,enum=acl.ACLChange_UserPermissions" json:"permissions,omitempty"`
|
|
InviteId string `protobuf:"bytes,5,opt,name=InviteId,proto3" json:"InviteId,omitempty"`
|
|
}
|
|
|
|
func (m *ACLChange_UserInvite) Reset() { *m = ACLChange_UserInvite{} }
|
|
func (m *ACLChange_UserInvite) String() string { return proto.CompactTextString(m) }
|
|
func (*ACLChange_UserInvite) ProtoMessage() {}
|
|
func (*ACLChange_UserInvite) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_37a022c841a51877, []int{1, 7}
|
|
}
|
|
func (m *ACLChange_UserInvite) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *ACLChange_UserInvite) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_ACLChange_UserInvite.Marshal(b, m, deterministic)
|
|
} else {
|
|
b = b[:cap(b)]
|
|
n, err := m.MarshalToSizedBuffer(b)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return b[:n], nil
|
|
}
|
|
}
|
|
func (m *ACLChange_UserInvite) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_ACLChange_UserInvite.Merge(m, src)
|
|
}
|
|
func (m *ACLChange_UserInvite) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *ACLChange_UserInvite) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_ACLChange_UserInvite.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_ACLChange_UserInvite proto.InternalMessageInfo
|
|
|
|
func (m *ACLChange_UserInvite) GetAcceptPublicKey() []byte {
|
|
if m != nil {
|
|
return m.AcceptPublicKey
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ACLChange_UserInvite) GetEncryptPublicKey() []byte {
|
|
if m != nil {
|
|
return m.EncryptPublicKey
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ACLChange_UserInvite) GetEncryptedReadKeys() [][]byte {
|
|
if m != nil {
|
|
return m.EncryptedReadKeys
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ACLChange_UserInvite) GetPermissions() ACLChange_UserPermissions {
|
|
if m != nil {
|
|
return m.Permissions
|
|
}
|
|
return ACLChange_Admin
|
|
}
|
|
|
|
func (m *ACLChange_UserInvite) GetInviteId() string {
|
|
if m != nil {
|
|
return m.InviteId
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type ACLChange_UserJoin struct {
|
|
Identity string `protobuf:"bytes,1,opt,name=identity,proto3" json:"identity,omitempty"`
|
|
EncryptionKey []byte `protobuf:"bytes,2,opt,name=encryptionKey,proto3" json:"encryptionKey,omitempty"`
|
|
AcceptSignature []byte `protobuf:"bytes,3,opt,name=acceptSignature,proto3" json:"acceptSignature,omitempty"`
|
|
UserInviteId string `protobuf:"bytes,4,opt,name=userInviteId,proto3" json:"userInviteId,omitempty"`
|
|
EncryptedReadKeys [][]byte `protobuf:"bytes,5,rep,name=encryptedReadKeys,proto3" json:"encryptedReadKeys,omitempty"`
|
|
}
|
|
|
|
func (m *ACLChange_UserJoin) Reset() { *m = ACLChange_UserJoin{} }
|
|
func (m *ACLChange_UserJoin) String() string { return proto.CompactTextString(m) }
|
|
func (*ACLChange_UserJoin) ProtoMessage() {}
|
|
func (*ACLChange_UserJoin) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_37a022c841a51877, []int{1, 8}
|
|
}
|
|
func (m *ACLChange_UserJoin) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *ACLChange_UserJoin) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_ACLChange_UserJoin.Marshal(b, m, deterministic)
|
|
} else {
|
|
b = b[:cap(b)]
|
|
n, err := m.MarshalToSizedBuffer(b)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return b[:n], nil
|
|
}
|
|
}
|
|
func (m *ACLChange_UserJoin) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_ACLChange_UserJoin.Merge(m, src)
|
|
}
|
|
func (m *ACLChange_UserJoin) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *ACLChange_UserJoin) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_ACLChange_UserJoin.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_ACLChange_UserJoin proto.InternalMessageInfo
|
|
|
|
func (m *ACLChange_UserJoin) GetIdentity() string {
|
|
if m != nil {
|
|
return m.Identity
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *ACLChange_UserJoin) GetEncryptionKey() []byte {
|
|
if m != nil {
|
|
return m.EncryptionKey
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ACLChange_UserJoin) GetAcceptSignature() []byte {
|
|
if m != nil {
|
|
return m.AcceptSignature
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ACLChange_UserJoin) GetUserInviteId() string {
|
|
if m != nil {
|
|
return m.UserInviteId
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *ACLChange_UserJoin) GetEncryptedReadKeys() [][]byte {
|
|
if m != nil {
|
|
return m.EncryptedReadKeys
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type ACLChange_UserRemove struct {
|
|
Identity string `protobuf:"bytes,1,opt,name=identity,proto3" json:"identity,omitempty"`
|
|
ReadKeyReplaces []*ACLChange_ReadKeyReplace `protobuf:"bytes,3,rep,name=readKeyReplaces,proto3" json:"readKeyReplaces,omitempty"`
|
|
}
|
|
|
|
func (m *ACLChange_UserRemove) Reset() { *m = ACLChange_UserRemove{} }
|
|
func (m *ACLChange_UserRemove) String() string { return proto.CompactTextString(m) }
|
|
func (*ACLChange_UserRemove) ProtoMessage() {}
|
|
func (*ACLChange_UserRemove) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_37a022c841a51877, []int{1, 9}
|
|
}
|
|
func (m *ACLChange_UserRemove) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *ACLChange_UserRemove) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_ACLChange_UserRemove.Marshal(b, m, deterministic)
|
|
} else {
|
|
b = b[:cap(b)]
|
|
n, err := m.MarshalToSizedBuffer(b)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return b[:n], nil
|
|
}
|
|
}
|
|
func (m *ACLChange_UserRemove) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_ACLChange_UserRemove.Merge(m, src)
|
|
}
|
|
func (m *ACLChange_UserRemove) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *ACLChange_UserRemove) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_ACLChange_UserRemove.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_ACLChange_UserRemove proto.InternalMessageInfo
|
|
|
|
func (m *ACLChange_UserRemove) GetIdentity() string {
|
|
if m != nil {
|
|
return m.Identity
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *ACLChange_UserRemove) GetReadKeyReplaces() []*ACLChange_ReadKeyReplace {
|
|
if m != nil {
|
|
return m.ReadKeyReplaces
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type ACLChange_ReadKeyReplace struct {
|
|
Identity string `protobuf:"bytes,1,opt,name=identity,proto3" json:"identity,omitempty"`
|
|
EncryptionKey []byte `protobuf:"bytes,2,opt,name=encryptionKey,proto3" json:"encryptionKey,omitempty"`
|
|
EncryptedReadKey []byte `protobuf:"bytes,3,opt,name=encryptedReadKey,proto3" json:"encryptedReadKey,omitempty"`
|
|
}
|
|
|
|
func (m *ACLChange_ReadKeyReplace) Reset() { *m = ACLChange_ReadKeyReplace{} }
|
|
func (m *ACLChange_ReadKeyReplace) String() string { return proto.CompactTextString(m) }
|
|
func (*ACLChange_ReadKeyReplace) ProtoMessage() {}
|
|
func (*ACLChange_ReadKeyReplace) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_37a022c841a51877, []int{1, 10}
|
|
}
|
|
func (m *ACLChange_ReadKeyReplace) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *ACLChange_ReadKeyReplace) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_ACLChange_ReadKeyReplace.Marshal(b, m, deterministic)
|
|
} else {
|
|
b = b[:cap(b)]
|
|
n, err := m.MarshalToSizedBuffer(b)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return b[:n], nil
|
|
}
|
|
}
|
|
func (m *ACLChange_ReadKeyReplace) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_ACLChange_ReadKeyReplace.Merge(m, src)
|
|
}
|
|
func (m *ACLChange_ReadKeyReplace) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *ACLChange_ReadKeyReplace) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_ACLChange_ReadKeyReplace.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_ACLChange_ReadKeyReplace proto.InternalMessageInfo
|
|
|
|
func (m *ACLChange_ReadKeyReplace) GetIdentity() string {
|
|
if m != nil {
|
|
return m.Identity
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *ACLChange_ReadKeyReplace) GetEncryptionKey() []byte {
|
|
if m != nil {
|
|
return m.EncryptionKey
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (m *ACLChange_ReadKeyReplace) GetEncryptedReadKey() []byte {
|
|
if m != nil {
|
|
return m.EncryptedReadKey
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type ACLChange_UserPermissionChange struct {
|
|
Identity string `protobuf:"bytes,1,opt,name=identity,proto3" json:"identity,omitempty"`
|
|
Permissions ACLChange_UserPermissions `protobuf:"varint,2,opt,name=permissions,proto3,enum=acl.ACLChange_UserPermissions" json:"permissions,omitempty"`
|
|
}
|
|
|
|
func (m *ACLChange_UserPermissionChange) Reset() { *m = ACLChange_UserPermissionChange{} }
|
|
func (m *ACLChange_UserPermissionChange) String() string { return proto.CompactTextString(m) }
|
|
func (*ACLChange_UserPermissionChange) ProtoMessage() {}
|
|
func (*ACLChange_UserPermissionChange) Descriptor() ([]byte, []int) {
|
|
return fileDescriptor_37a022c841a51877, []int{1, 11}
|
|
}
|
|
func (m *ACLChange_UserPermissionChange) XXX_Unmarshal(b []byte) error {
|
|
return m.Unmarshal(b)
|
|
}
|
|
func (m *ACLChange_UserPermissionChange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
|
if deterministic {
|
|
return xxx_messageInfo_ACLChange_UserPermissionChange.Marshal(b, m, deterministic)
|
|
} else {
|
|
b = b[:cap(b)]
|
|
n, err := m.MarshalToSizedBuffer(b)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return b[:n], nil
|
|
}
|
|
}
|
|
func (m *ACLChange_UserPermissionChange) XXX_Merge(src proto.Message) {
|
|
xxx_messageInfo_ACLChange_UserPermissionChange.Merge(m, src)
|
|
}
|
|
func (m *ACLChange_UserPermissionChange) XXX_Size() int {
|
|
return m.Size()
|
|
}
|
|
func (m *ACLChange_UserPermissionChange) XXX_DiscardUnknown() {
|
|
xxx_messageInfo_ACLChange_UserPermissionChange.DiscardUnknown(m)
|
|
}
|
|
|
|
var xxx_messageInfo_ACLChange_UserPermissionChange proto.InternalMessageInfo
|
|
|
|
func (m *ACLChange_UserPermissionChange) GetIdentity() string {
|
|
if m != nil {
|
|
return m.Identity
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (m *ACLChange_UserPermissionChange) GetPermissions() ACLChange_UserPermissions {
|
|
if m != nil {
|
|
return m.Permissions
|
|
}
|
|
return ACLChange_Admin
|
|
}
|
|
|
|
func init() {
|
|
proto.RegisterEnum("acl.ACLChange_UserPermissions", ACLChange_UserPermissions_name, ACLChange_UserPermissions_value)
|
|
proto.RegisterType((*RawChange)(nil), "acl.RawChange")
|
|
proto.RegisterType((*ACLChange)(nil), "acl.ACLChange")
|
|
proto.RegisterType((*ACLChange_ACLContentValue)(nil), "acl.ACLChange.ACLContentValue")
|
|
proto.RegisterType((*ACLChange_ACLData)(nil), "acl.ACLChange.ACLData")
|
|
proto.RegisterType((*ACLChange_ACLSnapshot)(nil), "acl.ACLChange.ACLSnapshot")
|
|
proto.RegisterType((*ACLChange_ACLState)(nil), "acl.ACLChange.ACLState")
|
|
proto.RegisterMapType((map[string]*ACLChange_UserInvite)(nil), "acl.ACLChange.ACLState.InvitesEntry")
|
|
proto.RegisterType((*ACLChange_UserState)(nil), "acl.ACLChange.UserState")
|
|
proto.RegisterType((*ACLChange_UserAdd)(nil), "acl.ACLChange.UserAdd")
|
|
proto.RegisterType((*ACLChange_UserConfirm)(nil), "acl.ACLChange.UserConfirm")
|
|
proto.RegisterType((*ACLChange_UserInvite)(nil), "acl.ACLChange.UserInvite")
|
|
proto.RegisterType((*ACLChange_UserJoin)(nil), "acl.ACLChange.UserJoin")
|
|
proto.RegisterType((*ACLChange_UserRemove)(nil), "acl.ACLChange.UserRemove")
|
|
proto.RegisterType((*ACLChange_ReadKeyReplace)(nil), "acl.ACLChange.ReadKeyReplace")
|
|
proto.RegisterType((*ACLChange_UserPermissionChange)(nil), "acl.ACLChange.UserPermissionChange")
|
|
}
|
|
|
|
func init() {
|
|
proto.RegisterFile("pkg/acl/aclchanges/aclpb/protos/aclchanges.proto", fileDescriptor_37a022c841a51877)
|
|
}
|
|
|
|
var fileDescriptor_37a022c841a51877 = []byte{
|
|
// 948 bytes of a gzipped FileDescriptorProto
|
|
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x56, 0x4f, 0x6f, 0xe3, 0x44,
|
|
0x14, 0xf7, 0xc4, 0x4d, 0x1d, 0x3f, 0x87, 0x36, 0x0c, 0x2b, 0xd6, 0x58, 0x4b, 0x88, 0xca, 0x0a,
|
|
0x45, 0x08, 0xa5, 0xab, 0xac, 0x90, 0x56, 0x80, 0x2a, 0xda, 0x82, 0x36, 0xa1, 0x1c, 0x56, 0x53,
|
|
0x2d, 0x08, 0x6e, 0x53, 0x7b, 0x68, 0xad, 0x75, 0x6c, 0xe3, 0x99, 0x14, 0xe5, 0x82, 0xc4, 0x89,
|
|
0x2b, 0x67, 0xbe, 0x0a, 0x5f, 0x60, 0x8f, 0x7b, 0xe4, 0x06, 0x6a, 0xef, 0x5c, 0xf8, 0x02, 0x68,
|
|
0xfe, 0xd8, 0x71, 0x12, 0x6f, 0x24, 0xa4, 0x15, 0x12, 0x87, 0x4a, 0x33, 0xbf, 0xf7, 0x7b, 0xd3,
|
|
0xf7, 0xde, 0xef, 0xbd, 0x17, 0xc3, 0x83, 0xfc, 0xd9, 0xe5, 0x21, 0x0d, 0x13, 0xf9, 0x17, 0x5e,
|
|
0xd1, 0xf4, 0x92, 0x71, 0x79, 0xcc, 0x2f, 0x0e, 0xf3, 0x22, 0x13, 0x19, 0xaf, 0xe1, 0x23, 0x85,
|
|
0x60, 0x9b, 0x86, 0xc9, 0xc1, 0x39, 0xb8, 0x84, 0xfe, 0x70, 0xaa, 0x0c, 0xd8, 0x07, 0x27, 0xa7,
|
|
0x8b, 0x24, 0xa3, 0x91, 0x8f, 0x06, 0x68, 0xd8, 0x25, 0xe5, 0x15, 0xdf, 0x03, 0x97, 0xc7, 0x97,
|
|
0x29, 0x15, 0xf3, 0x82, 0xf9, 0x2d, 0x65, 0x5b, 0x02, 0x78, 0x0f, 0x5a, 0x71, 0xe4, 0xdb, 0x03,
|
|
0x34, 0x74, 0x49, 0x2b, 0x8e, 0x0e, 0xfe, 0x7e, 0x03, 0xdc, 0xe3, 0xd3, 0x2f, 0xcd, 0xab, 0x03,
|
|
0xf0, 0x44, 0xc1, 0xd8, 0x84, 0xd1, 0x68, 0x1a, 0x71, 0x1f, 0x0d, 0xec, 0xa1, 0x4b, 0xea, 0x10,
|
|
0xee, 0x03, 0xd0, 0x30, 0x29, 0x09, 0x2d, 0x45, 0xa8, 0x21, 0xf8, 0x3d, 0xd8, 0xe3, 0x29, 0xcd,
|
|
0xf9, 0x55, 0x26, 0x4e, 0x28, 0x67, 0xd3, 0xf2, 0x7f, 0xad, 0xa1, 0xf8, 0x01, 0x38, 0x34, 0x4c,
|
|
0x3e, 0xa3, 0x82, 0xfa, 0x3b, 0x03, 0x34, 0xf4, 0xc6, 0x6f, 0x8e, 0x68, 0x98, 0x8c, 0xaa, 0x50,
|
|
0xe4, 0x49, 0x5a, 0x49, 0x49, 0x93, 0xb1, 0x99, 0xa2, 0x28, 0xaf, 0xb6, 0xca, 0xac, 0x0e, 0xe1,
|
|
0x11, 0xe0, 0x70, 0x5e, 0x14, 0x2c, 0x15, 0x84, 0xd1, 0xe8, 0x8c, 0x2d, 0x26, 0x94, 0x5f, 0xf9,
|
|
0xbb, 0x03, 0x34, 0xdc, 0x21, 0x0d, 0x16, 0x59, 0x29, 0x11, 0xcf, 0x18, 0x17, 0x74, 0x96, 0xfb,
|
|
0xce, 0x00, 0x0d, 0x6d, 0xb2, 0x04, 0x70, 0x00, 0x9d, 0x38, 0x62, 0xa9, 0x88, 0xc5, 0xc2, 0xef,
|
|
0xa8, 0x1c, 0xaa, 0x7b, 0xf0, 0xab, 0x0d, 0xfb, 0x32, 0xd4, 0x2c, 0x15, 0x2c, 0x15, 0x5f, 0xd1,
|
|
0x64, 0xce, 0xf0, 0x18, 0x9c, 0x39, 0x67, 0xc5, 0x71, 0xa4, 0x15, 0xd9, 0xcc, 0xe8, 0xa9, 0xb6,
|
|
0x4e, 0x2c, 0x52, 0x12, 0xf1, 0xc7, 0x00, 0xf2, 0x48, 0xd8, 0x2c, 0xbb, 0xd6, 0x62, 0x79, 0xe3,
|
|
0xb7, 0x1a, 0xdc, 0x34, 0x61, 0x62, 0x91, 0x1a, 0x1d, 0x7f, 0x03, 0x77, 0xe4, 0xed, 0x09, 0x2b,
|
|
0x66, 0x31, 0xe7, 0x71, 0x96, 0x6a, 0x07, 0x55, 0x70, 0x6f, 0xfc, 0x6e, 0xc3, 0x33, 0xeb, 0xd4,
|
|
0x89, 0x45, 0x1a, 0x9f, 0x28, 0xe3, 0x9a, 0xa6, 0xd7, 0xb1, 0x60, 0x46, 0xa0, 0xa6, 0xb8, 0x34,
|
|
0xa1, 0x8c, 0x4b, 0xdf, 0xf0, 0x87, 0xd0, 0x91, 0xb7, 0x2f, 0xb2, 0x38, 0x55, 0x2a, 0x79, 0xe3,
|
|
0xbb, 0x0d, 0xae, 0xd2, 0x3c, 0xb1, 0x48, 0x45, 0xc5, 0x47, 0xe0, 0xc9, 0xf3, 0x69, 0x96, 0x7e,
|
|
0x17, 0x17, 0x33, 0x25, 0x9b, 0x37, 0x0e, 0x1a, 0x3c, 0x0d, 0x63, 0x62, 0x91, 0xba, 0xc3, 0x89,
|
|
0x03, 0xed, 0x6b, 0x29, 0x44, 0xf0, 0x33, 0x02, 0xc7, 0x74, 0x0f, 0xfe, 0x04, 0x3c, 0x1a, 0x26,
|
|
0xe7, 0xa6, 0xf7, 0x8c, 0x30, 0xc1, 0x66, 0xab, 0x95, 0x0c, 0x52, 0xa7, 0xe3, 0x23, 0xd5, 0xec,
|
|
0x46, 0x65, 0xd5, 0xec, 0xde, 0xb8, 0xbf, 0xe9, 0x5c, 0x6f, 0x03, 0x52, 0xf3, 0x08, 0x4e, 0xc0,
|
|
0xab, 0xbd, 0x8d, 0x1f, 0x42, 0x47, 0xbe, 0x2e, 0xa8, 0x60, 0x26, 0x92, 0xbb, 0x0d, 0x91, 0x48,
|
|
0x33, 0xa9, 0x88, 0xc1, 0x4f, 0x2d, 0xe8, 0x94, 0x30, 0xbe, 0x0f, 0xaf, 0x15, 0xcb, 0x06, 0x66,
|
|
0x7a, 0x42, 0x77, 0xc8, 0x2a, 0x88, 0x1f, 0x69, 0xf5, 0x94, 0x0b, 0x37, 0x61, 0xfb, 0x0d, 0x85,
|
|
0xd4, 0xff, 0xaa, 0xc6, 0xc5, 0x47, 0xe0, 0xc4, 0x4a, 0x44, 0xee, 0xdb, 0xca, 0xed, 0xfe, 0x4b,
|
|
0x02, 0x1c, 0x69, 0xad, 0xf9, 0xe7, 0xa9, 0x28, 0x16, 0xa4, 0x74, 0x0a, 0x9e, 0x42, 0xb7, 0x6e,
|
|
0xc0, 0x3d, 0xb0, 0x9f, 0xb1, 0x85, 0x4a, 0xd6, 0x25, 0xf2, 0x88, 0x0f, 0x8d, 0x4a, 0x5b, 0x9a,
|
|
0x5d, 0xbf, 0x40, 0x34, 0xef, 0xa3, 0xd6, 0x23, 0x14, 0xfc, 0x81, 0xc0, 0xad, 0x02, 0x5e, 0x19,
|
|
0x4c, 0xb4, 0x3a, 0x98, 0xb2, 0x40, 0x2c, 0x0d, 0x8b, 0x45, 0x2e, 0xe2, 0x2c, 0x3d, 0x63, 0x0b,
|
|
0xb3, 0x00, 0x57, 0x41, 0xfc, 0x01, 0xbc, 0x6e, 0x00, 0x16, 0x99, 0x85, 0xa0, 0x13, 0xee, 0x92,
|
|
0x4d, 0x03, 0xfe, 0x14, 0xbc, 0xbc, 0x1a, 0x10, 0xae, 0xa6, 0x61, 0x6f, 0xa3, 0x0d, 0x56, 0xc7,
|
|
0x8b, 0x93, 0xba, 0x8b, 0x5c, 0x5d, 0x53, 0x6e, 0xfa, 0x94, 0x45, 0x6a, 0x28, 0x3a, 0xa4, 0x0e,
|
|
0x05, 0xbf, 0x21, 0x70, 0xcc, 0x7e, 0xf8, 0xff, 0xe5, 0x17, 0x3c, 0x06, 0xaf, 0x36, 0x98, 0x5b,
|
|
0x13, 0xb8, 0x07, 0xae, 0x59, 0x7e, 0xd3, 0x48, 0x05, 0xef, 0x92, 0x25, 0x10, 0xfc, 0x85, 0x00,
|
|
0x96, 0x2d, 0x80, 0x87, 0xb0, 0x4f, 0xc3, 0x90, 0xe5, 0xe2, 0xc9, 0xfc, 0x22, 0x89, 0xc3, 0x33,
|
|
0xd3, 0x4a, 0x5d, 0xb2, 0x0e, 0xe3, 0xf7, 0xa1, 0x67, 0x12, 0x5b, 0x52, 0x75, 0x69, 0x36, 0xf0,
|
|
0xff, 0x5c, 0xfd, 0x00, 0x3a, 0x3a, 0x9f, 0xa9, 0x96, 0xde, 0x25, 0xd5, 0x3d, 0x78, 0x8e, 0xa0,
|
|
0x53, 0x6e, 0xc3, 0x57, 0x20, 0x7c, 0x55, 0xb0, 0xf3, 0xea, 0x0b, 0xc0, 0xae, 0x17, 0xac, 0x82,
|
|
0xf1, 0x01, 0x74, 0x97, 0x2b, 0x7b, 0x1a, 0xa9, 0xbc, 0x5c, 0xb2, 0x82, 0x35, 0x17, 0xaa, 0xfd,
|
|
0x92, 0x42, 0x05, 0xdf, 0x6b, 0xe9, 0xcc, 0x8f, 0xd3, 0xb6, 0x5c, 0x1e, 0xc3, 0xbe, 0x59, 0x58,
|
|
0x84, 0xe5, 0x09, 0x0d, 0xab, 0x6d, 0xf3, 0xf6, 0x5a, 0x59, 0xc9, 0x0a, 0x8b, 0xac, 0x7b, 0x05,
|
|
0x3f, 0xc2, 0xde, 0x2a, 0xe5, 0x15, 0x94, 0x70, 0xd9, 0x49, 0x55, 0x6e, 0xa6, 0x86, 0x1b, 0x78,
|
|
0x20, 0xe0, 0x4e, 0xd3, 0xcf, 0xea, 0xd6, 0x28, 0xd6, 0xfa, 0xa9, 0xf5, 0xaf, 0xfb, 0xe9, 0xe0,
|
|
0x18, 0xf6, 0xd7, 0xec, 0xd8, 0x85, 0xf6, 0x71, 0x34, 0x8b, 0xd3, 0x9e, 0x85, 0x01, 0x76, 0xbf,
|
|
0x2e, 0x62, 0xc1, 0x8a, 0x1e, 0x92, 0x67, 0x19, 0x2a, 0x2b, 0x7a, 0x2d, 0xec, 0x81, 0xa3, 0xa5,
|
|
0x89, 0x7a, 0xf6, 0xc9, 0x3b, 0xcf, 0x6f, 0xfa, 0xe8, 0xc5, 0x4d, 0x1f, 0xfd, 0x79, 0xd3, 0x47,
|
|
0xbf, 0xdc, 0xf6, 0xad, 0x17, 0xb7, 0x7d, 0xeb, 0xf7, 0xdb, 0xbe, 0xf5, 0x6d, 0x5b, 0x7d, 0x88,
|
|
0x5e, 0xec, 0xaa, 0xef, 0xce, 0x87, 0xff, 0x04, 0x00, 0x00, 0xff, 0xff, 0x2a, 0xe8, 0x23, 0x71,
|
|
0xab, 0x0a, 0x00, 0x00,
|
|
}
|
|
|
|
func (m *RawChange) Marshal() (dAtA []byte, err error) {
|
|
size := m.Size()
|
|
dAtA = make([]byte, size)
|
|
n, err := m.MarshalToSizedBuffer(dAtA[:size])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return dAtA[:n], nil
|
|
}
|
|
|
|
func (m *RawChange) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *RawChange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Id) > 0 {
|
|
i -= len(m.Id)
|
|
copy(dAtA[i:], m.Id)
|
|
i = encodeVarintAclchanges(dAtA, i, uint64(len(m.Id)))
|
|
i--
|
|
dAtA[i] = 0x1a
|
|
}
|
|
if len(m.Signature) > 0 {
|
|
i -= len(m.Signature)
|
|
copy(dAtA[i:], m.Signature)
|
|
i = encodeVarintAclchanges(dAtA, i, uint64(len(m.Signature)))
|
|
i--
|
|
dAtA[i] = 0x12
|
|
}
|
|
if len(m.Payload) > 0 {
|
|
i -= len(m.Payload)
|
|
copy(dAtA[i:], m.Payload)
|
|
i = encodeVarintAclchanges(dAtA, i, uint64(len(m.Payload)))
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *ACLChange) Marshal() (dAtA []byte, err error) {
|
|
size := m.Size()
|
|
dAtA = make([]byte, size)
|
|
n, err := m.MarshalToSizedBuffer(dAtA[:size])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return dAtA[:n], nil
|
|
}
|
|
|
|
func (m *ACLChange) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *ACLChange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Identity) > 0 {
|
|
i -= len(m.Identity)
|
|
copy(dAtA[i:], m.Identity)
|
|
i = encodeVarintAclchanges(dAtA, i, uint64(len(m.Identity)))
|
|
i--
|
|
dAtA[i] = 0x42
|
|
}
|
|
if m.Timestamp != 0 {
|
|
i = encodeVarintAclchanges(dAtA, i, uint64(m.Timestamp))
|
|
i--
|
|
dAtA[i] = 0x38
|
|
}
|
|
if m.CurrentReadKeyHash != 0 {
|
|
i = encodeVarintAclchanges(dAtA, i, uint64(m.CurrentReadKeyHash))
|
|
i--
|
|
dAtA[i] = 0x30
|
|
}
|
|
if len(m.ChangesData) > 0 {
|
|
i -= len(m.ChangesData)
|
|
copy(dAtA[i:], m.ChangesData)
|
|
i = encodeVarintAclchanges(dAtA, i, uint64(len(m.ChangesData)))
|
|
i--
|
|
dAtA[i] = 0x2a
|
|
}
|
|
if m.AclData != nil {
|
|
{
|
|
size, err := m.AclData.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintAclchanges(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x22
|
|
}
|
|
if len(m.SnapshotBaseId) > 0 {
|
|
i -= len(m.SnapshotBaseId)
|
|
copy(dAtA[i:], m.SnapshotBaseId)
|
|
i = encodeVarintAclchanges(dAtA, i, uint64(len(m.SnapshotBaseId)))
|
|
i--
|
|
dAtA[i] = 0x1a
|
|
}
|
|
if len(m.AclHeadIds) > 0 {
|
|
for iNdEx := len(m.AclHeadIds) - 1; iNdEx >= 0; iNdEx-- {
|
|
i -= len(m.AclHeadIds[iNdEx])
|
|
copy(dAtA[i:], m.AclHeadIds[iNdEx])
|
|
i = encodeVarintAclchanges(dAtA, i, uint64(len(m.AclHeadIds[iNdEx])))
|
|
i--
|
|
dAtA[i] = 0x12
|
|
}
|
|
}
|
|
if len(m.TreeHeadIds) > 0 {
|
|
for iNdEx := len(m.TreeHeadIds) - 1; iNdEx >= 0; iNdEx-- {
|
|
i -= len(m.TreeHeadIds[iNdEx])
|
|
copy(dAtA[i:], m.TreeHeadIds[iNdEx])
|
|
i = encodeVarintAclchanges(dAtA, i, uint64(len(m.TreeHeadIds[iNdEx])))
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *ACLChange_ACLContentValue) Marshal() (dAtA []byte, err error) {
|
|
size := m.Size()
|
|
dAtA = make([]byte, size)
|
|
n, err := m.MarshalToSizedBuffer(dAtA[:size])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return dAtA[:n], nil
|
|
}
|
|
|
|
func (m *ACLChange_ACLContentValue) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *ACLChange_ACLContentValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Value != nil {
|
|
{
|
|
size := m.Value.Size()
|
|
i -= size
|
|
if _, err := m.Value.MarshalTo(dAtA[i:]); err != nil {
|
|
return 0, err
|
|
}
|
|
}
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *ACLChange_ACLContent_Value_UserAdd) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *ACLChange_ACLContent_Value_UserAdd) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
if m.UserAdd != nil {
|
|
{
|
|
size, err := m.UserAdd.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintAclchanges(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
func (m *ACLChange_ACLContent_Value_UserRemove) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *ACLChange_ACLContent_Value_UserRemove) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
if m.UserRemove != nil {
|
|
{
|
|
size, err := m.UserRemove.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintAclchanges(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x12
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
func (m *ACLChange_ACLContent_Value_UserPermissionChange) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *ACLChange_ACLContent_Value_UserPermissionChange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
if m.UserPermissionChange != nil {
|
|
{
|
|
size, err := m.UserPermissionChange.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintAclchanges(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x1a
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
func (m *ACLChange_ACLContent_Value_UserInvite) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *ACLChange_ACLContent_Value_UserInvite) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
if m.UserInvite != nil {
|
|
{
|
|
size, err := m.UserInvite.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintAclchanges(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x22
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
func (m *ACLChange_ACLContent_Value_UserJoin) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *ACLChange_ACLContent_Value_UserJoin) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
if m.UserJoin != nil {
|
|
{
|
|
size, err := m.UserJoin.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintAclchanges(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x2a
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
func (m *ACLChange_ACLContent_Value_UserConfirm) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *ACLChange_ACLContent_Value_UserConfirm) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
if m.UserConfirm != nil {
|
|
{
|
|
size, err := m.UserConfirm.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintAclchanges(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x32
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
func (m *ACLChange_ACLData) Marshal() (dAtA []byte, err error) {
|
|
size := m.Size()
|
|
dAtA = make([]byte, size)
|
|
n, err := m.MarshalToSizedBuffer(dAtA[:size])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return dAtA[:n], nil
|
|
}
|
|
|
|
func (m *ACLChange_ACLData) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *ACLChange_ACLData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.AclContent) > 0 {
|
|
for iNdEx := len(m.AclContent) - 1; iNdEx >= 0; iNdEx-- {
|
|
{
|
|
size, err := m.AclContent[iNdEx].MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintAclchanges(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x12
|
|
}
|
|
}
|
|
if m.AclSnapshot != nil {
|
|
{
|
|
size, err := m.AclSnapshot.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintAclchanges(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *ACLChange_ACLSnapshot) Marshal() (dAtA []byte, err error) {
|
|
size := m.Size()
|
|
dAtA = make([]byte, size)
|
|
n, err := m.MarshalToSizedBuffer(dAtA[:size])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return dAtA[:n], nil
|
|
}
|
|
|
|
func (m *ACLChange_ACLSnapshot) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *ACLChange_ACLSnapshot) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.AclState != nil {
|
|
{
|
|
size, err := m.AclState.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintAclchanges(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *ACLChange_ACLState) Marshal() (dAtA []byte, err error) {
|
|
size := m.Size()
|
|
dAtA = make([]byte, size)
|
|
n, err := m.MarshalToSizedBuffer(dAtA[:size])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return dAtA[:n], nil
|
|
}
|
|
|
|
func (m *ACLChange_ACLState) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *ACLChange_ACLState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.Invites) > 0 {
|
|
for k := range m.Invites {
|
|
v := m.Invites[k]
|
|
baseI := i
|
|
if v != nil {
|
|
{
|
|
size, err := v.MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintAclchanges(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x12
|
|
}
|
|
i -= len(k)
|
|
copy(dAtA[i:], k)
|
|
i = encodeVarintAclchanges(dAtA, i, uint64(len(k)))
|
|
i--
|
|
dAtA[i] = 0xa
|
|
i = encodeVarintAclchanges(dAtA, i, uint64(baseI-i))
|
|
i--
|
|
dAtA[i] = 0x1a
|
|
}
|
|
}
|
|
if len(m.UserStates) > 0 {
|
|
for iNdEx := len(m.UserStates) - 1; iNdEx >= 0; iNdEx-- {
|
|
{
|
|
size, err := m.UserStates[iNdEx].MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintAclchanges(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x12
|
|
}
|
|
}
|
|
if len(m.ReadKeyHashes) > 0 {
|
|
dAtA12 := make([]byte, len(m.ReadKeyHashes)*10)
|
|
var j11 int
|
|
for _, num := range m.ReadKeyHashes {
|
|
for num >= 1<<7 {
|
|
dAtA12[j11] = uint8(uint64(num)&0x7f | 0x80)
|
|
num >>= 7
|
|
j11++
|
|
}
|
|
dAtA12[j11] = uint8(num)
|
|
j11++
|
|
}
|
|
i -= j11
|
|
copy(dAtA[i:], dAtA12[:j11])
|
|
i = encodeVarintAclchanges(dAtA, i, uint64(j11))
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *ACLChange_UserState) Marshal() (dAtA []byte, err error) {
|
|
size := m.Size()
|
|
dAtA = make([]byte, size)
|
|
n, err := m.MarshalToSizedBuffer(dAtA[:size])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return dAtA[:n], nil
|
|
}
|
|
|
|
func (m *ACLChange_UserState) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *ACLChange_UserState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.IsConfirmed {
|
|
i--
|
|
if m.IsConfirmed {
|
|
dAtA[i] = 1
|
|
} else {
|
|
dAtA[i] = 0
|
|
}
|
|
i--
|
|
dAtA[i] = 0x28
|
|
}
|
|
if m.Permissions != 0 {
|
|
i = encodeVarintAclchanges(dAtA, i, uint64(m.Permissions))
|
|
i--
|
|
dAtA[i] = 0x20
|
|
}
|
|
if len(m.EncryptedReadKeys) > 0 {
|
|
for iNdEx := len(m.EncryptedReadKeys) - 1; iNdEx >= 0; iNdEx-- {
|
|
i -= len(m.EncryptedReadKeys[iNdEx])
|
|
copy(dAtA[i:], m.EncryptedReadKeys[iNdEx])
|
|
i = encodeVarintAclchanges(dAtA, i, uint64(len(m.EncryptedReadKeys[iNdEx])))
|
|
i--
|
|
dAtA[i] = 0x1a
|
|
}
|
|
}
|
|
if len(m.EncryptionKey) > 0 {
|
|
i -= len(m.EncryptionKey)
|
|
copy(dAtA[i:], m.EncryptionKey)
|
|
i = encodeVarintAclchanges(dAtA, i, uint64(len(m.EncryptionKey)))
|
|
i--
|
|
dAtA[i] = 0x12
|
|
}
|
|
if len(m.Identity) > 0 {
|
|
i -= len(m.Identity)
|
|
copy(dAtA[i:], m.Identity)
|
|
i = encodeVarintAclchanges(dAtA, i, uint64(len(m.Identity)))
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *ACLChange_UserAdd) Marshal() (dAtA []byte, err error) {
|
|
size := m.Size()
|
|
dAtA = make([]byte, size)
|
|
n, err := m.MarshalToSizedBuffer(dAtA[:size])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return dAtA[:n], nil
|
|
}
|
|
|
|
func (m *ACLChange_UserAdd) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *ACLChange_UserAdd) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Permissions != 0 {
|
|
i = encodeVarintAclchanges(dAtA, i, uint64(m.Permissions))
|
|
i--
|
|
dAtA[i] = 0x20
|
|
}
|
|
if len(m.EncryptedReadKeys) > 0 {
|
|
for iNdEx := len(m.EncryptedReadKeys) - 1; iNdEx >= 0; iNdEx-- {
|
|
i -= len(m.EncryptedReadKeys[iNdEx])
|
|
copy(dAtA[i:], m.EncryptedReadKeys[iNdEx])
|
|
i = encodeVarintAclchanges(dAtA, i, uint64(len(m.EncryptedReadKeys[iNdEx])))
|
|
i--
|
|
dAtA[i] = 0x1a
|
|
}
|
|
}
|
|
if len(m.EncryptionKey) > 0 {
|
|
i -= len(m.EncryptionKey)
|
|
copy(dAtA[i:], m.EncryptionKey)
|
|
i = encodeVarintAclchanges(dAtA, i, uint64(len(m.EncryptionKey)))
|
|
i--
|
|
dAtA[i] = 0x12
|
|
}
|
|
if len(m.Identity) > 0 {
|
|
i -= len(m.Identity)
|
|
copy(dAtA[i:], m.Identity)
|
|
i = encodeVarintAclchanges(dAtA, i, uint64(len(m.Identity)))
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *ACLChange_UserConfirm) Marshal() (dAtA []byte, err error) {
|
|
size := m.Size()
|
|
dAtA = make([]byte, size)
|
|
n, err := m.MarshalToSizedBuffer(dAtA[:size])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return dAtA[:n], nil
|
|
}
|
|
|
|
func (m *ACLChange_UserConfirm) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *ACLChange_UserConfirm) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.UserAddId) > 0 {
|
|
i -= len(m.UserAddId)
|
|
copy(dAtA[i:], m.UserAddId)
|
|
i = encodeVarintAclchanges(dAtA, i, uint64(len(m.UserAddId)))
|
|
i--
|
|
dAtA[i] = 0x12
|
|
}
|
|
if len(m.Identity) > 0 {
|
|
i -= len(m.Identity)
|
|
copy(dAtA[i:], m.Identity)
|
|
i = encodeVarintAclchanges(dAtA, i, uint64(len(m.Identity)))
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *ACLChange_UserInvite) Marshal() (dAtA []byte, err error) {
|
|
size := m.Size()
|
|
dAtA = make([]byte, size)
|
|
n, err := m.MarshalToSizedBuffer(dAtA[:size])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return dAtA[:n], nil
|
|
}
|
|
|
|
func (m *ACLChange_UserInvite) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *ACLChange_UserInvite) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.InviteId) > 0 {
|
|
i -= len(m.InviteId)
|
|
copy(dAtA[i:], m.InviteId)
|
|
i = encodeVarintAclchanges(dAtA, i, uint64(len(m.InviteId)))
|
|
i--
|
|
dAtA[i] = 0x2a
|
|
}
|
|
if m.Permissions != 0 {
|
|
i = encodeVarintAclchanges(dAtA, i, uint64(m.Permissions))
|
|
i--
|
|
dAtA[i] = 0x20
|
|
}
|
|
if len(m.EncryptedReadKeys) > 0 {
|
|
for iNdEx := len(m.EncryptedReadKeys) - 1; iNdEx >= 0; iNdEx-- {
|
|
i -= len(m.EncryptedReadKeys[iNdEx])
|
|
copy(dAtA[i:], m.EncryptedReadKeys[iNdEx])
|
|
i = encodeVarintAclchanges(dAtA, i, uint64(len(m.EncryptedReadKeys[iNdEx])))
|
|
i--
|
|
dAtA[i] = 0x1a
|
|
}
|
|
}
|
|
if len(m.EncryptPublicKey) > 0 {
|
|
i -= len(m.EncryptPublicKey)
|
|
copy(dAtA[i:], m.EncryptPublicKey)
|
|
i = encodeVarintAclchanges(dAtA, i, uint64(len(m.EncryptPublicKey)))
|
|
i--
|
|
dAtA[i] = 0x12
|
|
}
|
|
if len(m.AcceptPublicKey) > 0 {
|
|
i -= len(m.AcceptPublicKey)
|
|
copy(dAtA[i:], m.AcceptPublicKey)
|
|
i = encodeVarintAclchanges(dAtA, i, uint64(len(m.AcceptPublicKey)))
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *ACLChange_UserJoin) Marshal() (dAtA []byte, err error) {
|
|
size := m.Size()
|
|
dAtA = make([]byte, size)
|
|
n, err := m.MarshalToSizedBuffer(dAtA[:size])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return dAtA[:n], nil
|
|
}
|
|
|
|
func (m *ACLChange_UserJoin) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *ACLChange_UserJoin) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.EncryptedReadKeys) > 0 {
|
|
for iNdEx := len(m.EncryptedReadKeys) - 1; iNdEx >= 0; iNdEx-- {
|
|
i -= len(m.EncryptedReadKeys[iNdEx])
|
|
copy(dAtA[i:], m.EncryptedReadKeys[iNdEx])
|
|
i = encodeVarintAclchanges(dAtA, i, uint64(len(m.EncryptedReadKeys[iNdEx])))
|
|
i--
|
|
dAtA[i] = 0x2a
|
|
}
|
|
}
|
|
if len(m.UserInviteId) > 0 {
|
|
i -= len(m.UserInviteId)
|
|
copy(dAtA[i:], m.UserInviteId)
|
|
i = encodeVarintAclchanges(dAtA, i, uint64(len(m.UserInviteId)))
|
|
i--
|
|
dAtA[i] = 0x22
|
|
}
|
|
if len(m.AcceptSignature) > 0 {
|
|
i -= len(m.AcceptSignature)
|
|
copy(dAtA[i:], m.AcceptSignature)
|
|
i = encodeVarintAclchanges(dAtA, i, uint64(len(m.AcceptSignature)))
|
|
i--
|
|
dAtA[i] = 0x1a
|
|
}
|
|
if len(m.EncryptionKey) > 0 {
|
|
i -= len(m.EncryptionKey)
|
|
copy(dAtA[i:], m.EncryptionKey)
|
|
i = encodeVarintAclchanges(dAtA, i, uint64(len(m.EncryptionKey)))
|
|
i--
|
|
dAtA[i] = 0x12
|
|
}
|
|
if len(m.Identity) > 0 {
|
|
i -= len(m.Identity)
|
|
copy(dAtA[i:], m.Identity)
|
|
i = encodeVarintAclchanges(dAtA, i, uint64(len(m.Identity)))
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *ACLChange_UserRemove) Marshal() (dAtA []byte, err error) {
|
|
size := m.Size()
|
|
dAtA = make([]byte, size)
|
|
n, err := m.MarshalToSizedBuffer(dAtA[:size])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return dAtA[:n], nil
|
|
}
|
|
|
|
func (m *ACLChange_UserRemove) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *ACLChange_UserRemove) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.ReadKeyReplaces) > 0 {
|
|
for iNdEx := len(m.ReadKeyReplaces) - 1; iNdEx >= 0; iNdEx-- {
|
|
{
|
|
size, err := m.ReadKeyReplaces[iNdEx].MarshalToSizedBuffer(dAtA[:i])
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
i -= size
|
|
i = encodeVarintAclchanges(dAtA, i, uint64(size))
|
|
}
|
|
i--
|
|
dAtA[i] = 0x1a
|
|
}
|
|
}
|
|
if len(m.Identity) > 0 {
|
|
i -= len(m.Identity)
|
|
copy(dAtA[i:], m.Identity)
|
|
i = encodeVarintAclchanges(dAtA, i, uint64(len(m.Identity)))
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *ACLChange_ReadKeyReplace) Marshal() (dAtA []byte, err error) {
|
|
size := m.Size()
|
|
dAtA = make([]byte, size)
|
|
n, err := m.MarshalToSizedBuffer(dAtA[:size])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return dAtA[:n], nil
|
|
}
|
|
|
|
func (m *ACLChange_ReadKeyReplace) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *ACLChange_ReadKeyReplace) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if len(m.EncryptedReadKey) > 0 {
|
|
i -= len(m.EncryptedReadKey)
|
|
copy(dAtA[i:], m.EncryptedReadKey)
|
|
i = encodeVarintAclchanges(dAtA, i, uint64(len(m.EncryptedReadKey)))
|
|
i--
|
|
dAtA[i] = 0x1a
|
|
}
|
|
if len(m.EncryptionKey) > 0 {
|
|
i -= len(m.EncryptionKey)
|
|
copy(dAtA[i:], m.EncryptionKey)
|
|
i = encodeVarintAclchanges(dAtA, i, uint64(len(m.EncryptionKey)))
|
|
i--
|
|
dAtA[i] = 0x12
|
|
}
|
|
if len(m.Identity) > 0 {
|
|
i -= len(m.Identity)
|
|
copy(dAtA[i:], m.Identity)
|
|
i = encodeVarintAclchanges(dAtA, i, uint64(len(m.Identity)))
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func (m *ACLChange_UserPermissionChange) Marshal() (dAtA []byte, err error) {
|
|
size := m.Size()
|
|
dAtA = make([]byte, size)
|
|
n, err := m.MarshalToSizedBuffer(dAtA[:size])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return dAtA[:n], nil
|
|
}
|
|
|
|
func (m *ACLChange_UserPermissionChange) MarshalTo(dAtA []byte) (int, error) {
|
|
size := m.Size()
|
|
return m.MarshalToSizedBuffer(dAtA[:size])
|
|
}
|
|
|
|
func (m *ACLChange_UserPermissionChange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
|
i := len(dAtA)
|
|
_ = i
|
|
var l int
|
|
_ = l
|
|
if m.Permissions != 0 {
|
|
i = encodeVarintAclchanges(dAtA, i, uint64(m.Permissions))
|
|
i--
|
|
dAtA[i] = 0x10
|
|
}
|
|
if len(m.Identity) > 0 {
|
|
i -= len(m.Identity)
|
|
copy(dAtA[i:], m.Identity)
|
|
i = encodeVarintAclchanges(dAtA, i, uint64(len(m.Identity)))
|
|
i--
|
|
dAtA[i] = 0xa
|
|
}
|
|
return len(dAtA) - i, nil
|
|
}
|
|
|
|
func encodeVarintAclchanges(dAtA []byte, offset int, v uint64) int {
|
|
offset -= sovAclchanges(v)
|
|
base := offset
|
|
for v >= 1<<7 {
|
|
dAtA[offset] = uint8(v&0x7f | 0x80)
|
|
v >>= 7
|
|
offset++
|
|
}
|
|
dAtA[offset] = uint8(v)
|
|
return base
|
|
}
|
|
func (m *RawChange) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
l = len(m.Payload)
|
|
if l > 0 {
|
|
n += 1 + l + sovAclchanges(uint64(l))
|
|
}
|
|
l = len(m.Signature)
|
|
if l > 0 {
|
|
n += 1 + l + sovAclchanges(uint64(l))
|
|
}
|
|
l = len(m.Id)
|
|
if l > 0 {
|
|
n += 1 + l + sovAclchanges(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *ACLChange) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if len(m.TreeHeadIds) > 0 {
|
|
for _, s := range m.TreeHeadIds {
|
|
l = len(s)
|
|
n += 1 + l + sovAclchanges(uint64(l))
|
|
}
|
|
}
|
|
if len(m.AclHeadIds) > 0 {
|
|
for _, s := range m.AclHeadIds {
|
|
l = len(s)
|
|
n += 1 + l + sovAclchanges(uint64(l))
|
|
}
|
|
}
|
|
l = len(m.SnapshotBaseId)
|
|
if l > 0 {
|
|
n += 1 + l + sovAclchanges(uint64(l))
|
|
}
|
|
if m.AclData != nil {
|
|
l = m.AclData.Size()
|
|
n += 1 + l + sovAclchanges(uint64(l))
|
|
}
|
|
l = len(m.ChangesData)
|
|
if l > 0 {
|
|
n += 1 + l + sovAclchanges(uint64(l))
|
|
}
|
|
if m.CurrentReadKeyHash != 0 {
|
|
n += 1 + sovAclchanges(uint64(m.CurrentReadKeyHash))
|
|
}
|
|
if m.Timestamp != 0 {
|
|
n += 1 + sovAclchanges(uint64(m.Timestamp))
|
|
}
|
|
l = len(m.Identity)
|
|
if l > 0 {
|
|
n += 1 + l + sovAclchanges(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *ACLChange_ACLContentValue) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.Value != nil {
|
|
n += m.Value.Size()
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *ACLChange_ACLContent_Value_UserAdd) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.UserAdd != nil {
|
|
l = m.UserAdd.Size()
|
|
n += 1 + l + sovAclchanges(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
func (m *ACLChange_ACLContent_Value_UserRemove) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.UserRemove != nil {
|
|
l = m.UserRemove.Size()
|
|
n += 1 + l + sovAclchanges(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
func (m *ACLChange_ACLContent_Value_UserPermissionChange) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.UserPermissionChange != nil {
|
|
l = m.UserPermissionChange.Size()
|
|
n += 1 + l + sovAclchanges(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
func (m *ACLChange_ACLContent_Value_UserInvite) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.UserInvite != nil {
|
|
l = m.UserInvite.Size()
|
|
n += 1 + l + sovAclchanges(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
func (m *ACLChange_ACLContent_Value_UserJoin) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.UserJoin != nil {
|
|
l = m.UserJoin.Size()
|
|
n += 1 + l + sovAclchanges(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
func (m *ACLChange_ACLContent_Value_UserConfirm) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.UserConfirm != nil {
|
|
l = m.UserConfirm.Size()
|
|
n += 1 + l + sovAclchanges(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
func (m *ACLChange_ACLData) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.AclSnapshot != nil {
|
|
l = m.AclSnapshot.Size()
|
|
n += 1 + l + sovAclchanges(uint64(l))
|
|
}
|
|
if len(m.AclContent) > 0 {
|
|
for _, e := range m.AclContent {
|
|
l = e.Size()
|
|
n += 1 + l + sovAclchanges(uint64(l))
|
|
}
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *ACLChange_ACLSnapshot) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if m.AclState != nil {
|
|
l = m.AclState.Size()
|
|
n += 1 + l + sovAclchanges(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *ACLChange_ACLState) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
if len(m.ReadKeyHashes) > 0 {
|
|
l = 0
|
|
for _, e := range m.ReadKeyHashes {
|
|
l += sovAclchanges(uint64(e))
|
|
}
|
|
n += 1 + sovAclchanges(uint64(l)) + l
|
|
}
|
|
if len(m.UserStates) > 0 {
|
|
for _, e := range m.UserStates {
|
|
l = e.Size()
|
|
n += 1 + l + sovAclchanges(uint64(l))
|
|
}
|
|
}
|
|
if len(m.Invites) > 0 {
|
|
for k, v := range m.Invites {
|
|
_ = k
|
|
_ = v
|
|
l = 0
|
|
if v != nil {
|
|
l = v.Size()
|
|
l += 1 + sovAclchanges(uint64(l))
|
|
}
|
|
mapEntrySize := 1 + len(k) + sovAclchanges(uint64(len(k))) + l
|
|
n += mapEntrySize + 1 + sovAclchanges(uint64(mapEntrySize))
|
|
}
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *ACLChange_UserState) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
l = len(m.Identity)
|
|
if l > 0 {
|
|
n += 1 + l + sovAclchanges(uint64(l))
|
|
}
|
|
l = len(m.EncryptionKey)
|
|
if l > 0 {
|
|
n += 1 + l + sovAclchanges(uint64(l))
|
|
}
|
|
if len(m.EncryptedReadKeys) > 0 {
|
|
for _, b := range m.EncryptedReadKeys {
|
|
l = len(b)
|
|
n += 1 + l + sovAclchanges(uint64(l))
|
|
}
|
|
}
|
|
if m.Permissions != 0 {
|
|
n += 1 + sovAclchanges(uint64(m.Permissions))
|
|
}
|
|
if m.IsConfirmed {
|
|
n += 2
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *ACLChange_UserAdd) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
l = len(m.Identity)
|
|
if l > 0 {
|
|
n += 1 + l + sovAclchanges(uint64(l))
|
|
}
|
|
l = len(m.EncryptionKey)
|
|
if l > 0 {
|
|
n += 1 + l + sovAclchanges(uint64(l))
|
|
}
|
|
if len(m.EncryptedReadKeys) > 0 {
|
|
for _, b := range m.EncryptedReadKeys {
|
|
l = len(b)
|
|
n += 1 + l + sovAclchanges(uint64(l))
|
|
}
|
|
}
|
|
if m.Permissions != 0 {
|
|
n += 1 + sovAclchanges(uint64(m.Permissions))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *ACLChange_UserConfirm) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
l = len(m.Identity)
|
|
if l > 0 {
|
|
n += 1 + l + sovAclchanges(uint64(l))
|
|
}
|
|
l = len(m.UserAddId)
|
|
if l > 0 {
|
|
n += 1 + l + sovAclchanges(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *ACLChange_UserInvite) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
l = len(m.AcceptPublicKey)
|
|
if l > 0 {
|
|
n += 1 + l + sovAclchanges(uint64(l))
|
|
}
|
|
l = len(m.EncryptPublicKey)
|
|
if l > 0 {
|
|
n += 1 + l + sovAclchanges(uint64(l))
|
|
}
|
|
if len(m.EncryptedReadKeys) > 0 {
|
|
for _, b := range m.EncryptedReadKeys {
|
|
l = len(b)
|
|
n += 1 + l + sovAclchanges(uint64(l))
|
|
}
|
|
}
|
|
if m.Permissions != 0 {
|
|
n += 1 + sovAclchanges(uint64(m.Permissions))
|
|
}
|
|
l = len(m.InviteId)
|
|
if l > 0 {
|
|
n += 1 + l + sovAclchanges(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *ACLChange_UserJoin) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
l = len(m.Identity)
|
|
if l > 0 {
|
|
n += 1 + l + sovAclchanges(uint64(l))
|
|
}
|
|
l = len(m.EncryptionKey)
|
|
if l > 0 {
|
|
n += 1 + l + sovAclchanges(uint64(l))
|
|
}
|
|
l = len(m.AcceptSignature)
|
|
if l > 0 {
|
|
n += 1 + l + sovAclchanges(uint64(l))
|
|
}
|
|
l = len(m.UserInviteId)
|
|
if l > 0 {
|
|
n += 1 + l + sovAclchanges(uint64(l))
|
|
}
|
|
if len(m.EncryptedReadKeys) > 0 {
|
|
for _, b := range m.EncryptedReadKeys {
|
|
l = len(b)
|
|
n += 1 + l + sovAclchanges(uint64(l))
|
|
}
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *ACLChange_UserRemove) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
l = len(m.Identity)
|
|
if l > 0 {
|
|
n += 1 + l + sovAclchanges(uint64(l))
|
|
}
|
|
if len(m.ReadKeyReplaces) > 0 {
|
|
for _, e := range m.ReadKeyReplaces {
|
|
l = e.Size()
|
|
n += 1 + l + sovAclchanges(uint64(l))
|
|
}
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *ACLChange_ReadKeyReplace) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
l = len(m.Identity)
|
|
if l > 0 {
|
|
n += 1 + l + sovAclchanges(uint64(l))
|
|
}
|
|
l = len(m.EncryptionKey)
|
|
if l > 0 {
|
|
n += 1 + l + sovAclchanges(uint64(l))
|
|
}
|
|
l = len(m.EncryptedReadKey)
|
|
if l > 0 {
|
|
n += 1 + l + sovAclchanges(uint64(l))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func (m *ACLChange_UserPermissionChange) Size() (n int) {
|
|
if m == nil {
|
|
return 0
|
|
}
|
|
var l int
|
|
_ = l
|
|
l = len(m.Identity)
|
|
if l > 0 {
|
|
n += 1 + l + sovAclchanges(uint64(l))
|
|
}
|
|
if m.Permissions != 0 {
|
|
n += 1 + sovAclchanges(uint64(m.Permissions))
|
|
}
|
|
return n
|
|
}
|
|
|
|
func sovAclchanges(x uint64) (n int) {
|
|
return (math_bits.Len64(x|1) + 6) / 7
|
|
}
|
|
func sozAclchanges(x uint64) (n int) {
|
|
return sovAclchanges(uint64((x << 1) ^ uint64((int64(x) >> 63))))
|
|
}
|
|
func (m *RawChange) Unmarshal(dAtA []byte) error {
|
|
l := len(dAtA)
|
|
iNdEx := 0
|
|
for iNdEx < l {
|
|
preIndex := iNdEx
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
wire |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
fieldNum := int32(wire >> 3)
|
|
wireType := int(wire & 0x7)
|
|
if wireType == 4 {
|
|
return fmt.Errorf("proto: RawChange: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: RawChange: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Payload", wireType)
|
|
}
|
|
var byteLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
byteLen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if byteLen < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
postIndex := iNdEx + byteLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Payload = append(m.Payload[:0], dAtA[iNdEx:postIndex]...)
|
|
if m.Payload == nil {
|
|
m.Payload = []byte{}
|
|
}
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType)
|
|
}
|
|
var byteLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
byteLen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if byteLen < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
postIndex := iNdEx + byteLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...)
|
|
if m.Signature == nil {
|
|
m.Signature = []byte{}
|
|
}
|
|
iNdEx = postIndex
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Id = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipAclchanges(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if (skippy < 0) || (iNdEx+skippy) < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *ACLChange) Unmarshal(dAtA []byte) error {
|
|
l := len(dAtA)
|
|
iNdEx := 0
|
|
for iNdEx < l {
|
|
preIndex := iNdEx
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
wire |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
fieldNum := int32(wire >> 3)
|
|
wireType := int(wire & 0x7)
|
|
if wireType == 4 {
|
|
return fmt.Errorf("proto: ACLChange: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: ACLChange: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field TreeHeadIds", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.TreeHeadIds = append(m.TreeHeadIds, string(dAtA[iNdEx:postIndex]))
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field AclHeadIds", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.AclHeadIds = append(m.AclHeadIds, string(dAtA[iNdEx:postIndex]))
|
|
iNdEx = postIndex
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field SnapshotBaseId", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.SnapshotBaseId = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 4:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field AclData", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.AclData == nil {
|
|
m.AclData = &ACLChange_ACLData{}
|
|
}
|
|
if err := m.AclData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 5:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field ChangesData", wireType)
|
|
}
|
|
var byteLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
byteLen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if byteLen < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
postIndex := iNdEx + byteLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.ChangesData = append(m.ChangesData[:0], dAtA[iNdEx:postIndex]...)
|
|
if m.ChangesData == nil {
|
|
m.ChangesData = []byte{}
|
|
}
|
|
iNdEx = postIndex
|
|
case 6:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field CurrentReadKeyHash", wireType)
|
|
}
|
|
m.CurrentReadKeyHash = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.CurrentReadKeyHash |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 7:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
|
|
}
|
|
m.Timestamp = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Timestamp |= int64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 8:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Identity", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Identity = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipAclchanges(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if (skippy < 0) || (iNdEx+skippy) < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *ACLChange_ACLContentValue) Unmarshal(dAtA []byte) error {
|
|
l := len(dAtA)
|
|
iNdEx := 0
|
|
for iNdEx < l {
|
|
preIndex := iNdEx
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
wire |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
fieldNum := int32(wire >> 3)
|
|
wireType := int(wire & 0x7)
|
|
if wireType == 4 {
|
|
return fmt.Errorf("proto: ACLContentValue: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: ACLContentValue: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field UserAdd", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
v := &ACLChange_UserAdd{}
|
|
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
m.Value = &ACLChange_ACLContent_Value_UserAdd{v}
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field UserRemove", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
v := &ACLChange_UserRemove{}
|
|
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
m.Value = &ACLChange_ACLContent_Value_UserRemove{v}
|
|
iNdEx = postIndex
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field UserPermissionChange", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
v := &ACLChange_UserPermissionChange{}
|
|
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
m.Value = &ACLChange_ACLContent_Value_UserPermissionChange{v}
|
|
iNdEx = postIndex
|
|
case 4:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field UserInvite", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
v := &ACLChange_UserInvite{}
|
|
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
m.Value = &ACLChange_ACLContent_Value_UserInvite{v}
|
|
iNdEx = postIndex
|
|
case 5:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field UserJoin", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
v := &ACLChange_UserJoin{}
|
|
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
m.Value = &ACLChange_ACLContent_Value_UserJoin{v}
|
|
iNdEx = postIndex
|
|
case 6:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field UserConfirm", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
v := &ACLChange_UserConfirm{}
|
|
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
m.Value = &ACLChange_ACLContent_Value_UserConfirm{v}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipAclchanges(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if (skippy < 0) || (iNdEx+skippy) < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *ACLChange_ACLData) Unmarshal(dAtA []byte) error {
|
|
l := len(dAtA)
|
|
iNdEx := 0
|
|
for iNdEx < l {
|
|
preIndex := iNdEx
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
wire |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
fieldNum := int32(wire >> 3)
|
|
wireType := int(wire & 0x7)
|
|
if wireType == 4 {
|
|
return fmt.Errorf("proto: ACLData: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: ACLData: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field AclSnapshot", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.AclSnapshot == nil {
|
|
m.AclSnapshot = &ACLChange_ACLSnapshot{}
|
|
}
|
|
if err := m.AclSnapshot.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field AclContent", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.AclContent = append(m.AclContent, &ACLChange_ACLContentValue{})
|
|
if err := m.AclContent[len(m.AclContent)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipAclchanges(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if (skippy < 0) || (iNdEx+skippy) < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *ACLChange_ACLSnapshot) Unmarshal(dAtA []byte) error {
|
|
l := len(dAtA)
|
|
iNdEx := 0
|
|
for iNdEx < l {
|
|
preIndex := iNdEx
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
wire |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
fieldNum := int32(wire >> 3)
|
|
wireType := int(wire & 0x7)
|
|
if wireType == 4 {
|
|
return fmt.Errorf("proto: ACLSnapshot: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: ACLSnapshot: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field AclState", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.AclState == nil {
|
|
m.AclState = &ACLChange_ACLState{}
|
|
}
|
|
if err := m.AclState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipAclchanges(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if (skippy < 0) || (iNdEx+skippy) < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *ACLChange_ACLState) Unmarshal(dAtA []byte) error {
|
|
l := len(dAtA)
|
|
iNdEx := 0
|
|
for iNdEx < l {
|
|
preIndex := iNdEx
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
wire |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
fieldNum := int32(wire >> 3)
|
|
wireType := int(wire & 0x7)
|
|
if wireType == 4 {
|
|
return fmt.Errorf("proto: ACLState: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: ACLState: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType == 0 {
|
|
var v uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
v |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.ReadKeyHashes = append(m.ReadKeyHashes, v)
|
|
} else if wireType == 2 {
|
|
var packedLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
packedLen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if packedLen < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
postIndex := iNdEx + packedLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
var elementCount int
|
|
var count int
|
|
for _, integer := range dAtA[iNdEx:postIndex] {
|
|
if integer < 128 {
|
|
count++
|
|
}
|
|
}
|
|
elementCount = count
|
|
if elementCount != 0 && len(m.ReadKeyHashes) == 0 {
|
|
m.ReadKeyHashes = make([]uint64, 0, elementCount)
|
|
}
|
|
for iNdEx < postIndex {
|
|
var v uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
v |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.ReadKeyHashes = append(m.ReadKeyHashes, v)
|
|
}
|
|
} else {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field ReadKeyHashes", wireType)
|
|
}
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field UserStates", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.UserStates = append(m.UserStates, &ACLChange_UserState{})
|
|
if err := m.UserStates[len(m.UserStates)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Invites", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
if m.Invites == nil {
|
|
m.Invites = make(map[string]*ACLChange_UserInvite)
|
|
}
|
|
var mapkey string
|
|
var mapvalue *ACLChange_UserInvite
|
|
for iNdEx < postIndex {
|
|
entryPreIndex := iNdEx
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
wire |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
fieldNum := int32(wire >> 3)
|
|
if fieldNum == 1 {
|
|
var stringLenmapkey uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLenmapkey |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLenmapkey := int(stringLenmapkey)
|
|
if intStringLenmapkey < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
postStringIndexmapkey := iNdEx + intStringLenmapkey
|
|
if postStringIndexmapkey < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if postStringIndexmapkey > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
|
|
iNdEx = postStringIndexmapkey
|
|
} else if fieldNum == 2 {
|
|
var mapmsglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
mapmsglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if mapmsglen < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
postmsgIndex := iNdEx + mapmsglen
|
|
if postmsgIndex < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if postmsgIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
mapvalue = &ACLChange_UserInvite{}
|
|
if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postmsgIndex
|
|
} else {
|
|
iNdEx = entryPreIndex
|
|
skippy, err := skipAclchanges(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if (skippy < 0) || (iNdEx+skippy) < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if (iNdEx + skippy) > postIndex {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
m.Invites[mapkey] = mapvalue
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipAclchanges(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if (skippy < 0) || (iNdEx+skippy) < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *ACLChange_UserState) Unmarshal(dAtA []byte) error {
|
|
l := len(dAtA)
|
|
iNdEx := 0
|
|
for iNdEx < l {
|
|
preIndex := iNdEx
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
wire |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
fieldNum := int32(wire >> 3)
|
|
wireType := int(wire & 0x7)
|
|
if wireType == 4 {
|
|
return fmt.Errorf("proto: UserState: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: UserState: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Identity", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Identity = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field EncryptionKey", wireType)
|
|
}
|
|
var byteLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
byteLen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if byteLen < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
postIndex := iNdEx + byteLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.EncryptionKey = append(m.EncryptionKey[:0], dAtA[iNdEx:postIndex]...)
|
|
if m.EncryptionKey == nil {
|
|
m.EncryptionKey = []byte{}
|
|
}
|
|
iNdEx = postIndex
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field EncryptedReadKeys", wireType)
|
|
}
|
|
var byteLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
byteLen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if byteLen < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
postIndex := iNdEx + byteLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.EncryptedReadKeys = append(m.EncryptedReadKeys, make([]byte, postIndex-iNdEx))
|
|
copy(m.EncryptedReadKeys[len(m.EncryptedReadKeys)-1], dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 4:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Permissions", wireType)
|
|
}
|
|
m.Permissions = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Permissions |= ACLChange_UserPermissions(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 5:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field IsConfirmed", wireType)
|
|
}
|
|
var v int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
v |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
m.IsConfirmed = bool(v != 0)
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipAclchanges(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if (skippy < 0) || (iNdEx+skippy) < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *ACLChange_UserAdd) Unmarshal(dAtA []byte) error {
|
|
l := len(dAtA)
|
|
iNdEx := 0
|
|
for iNdEx < l {
|
|
preIndex := iNdEx
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
wire |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
fieldNum := int32(wire >> 3)
|
|
wireType := int(wire & 0x7)
|
|
if wireType == 4 {
|
|
return fmt.Errorf("proto: UserAdd: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: UserAdd: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Identity", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Identity = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field EncryptionKey", wireType)
|
|
}
|
|
var byteLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
byteLen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if byteLen < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
postIndex := iNdEx + byteLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.EncryptionKey = append(m.EncryptionKey[:0], dAtA[iNdEx:postIndex]...)
|
|
if m.EncryptionKey == nil {
|
|
m.EncryptionKey = []byte{}
|
|
}
|
|
iNdEx = postIndex
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field EncryptedReadKeys", wireType)
|
|
}
|
|
var byteLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
byteLen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if byteLen < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
postIndex := iNdEx + byteLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.EncryptedReadKeys = append(m.EncryptedReadKeys, make([]byte, postIndex-iNdEx))
|
|
copy(m.EncryptedReadKeys[len(m.EncryptedReadKeys)-1], dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 4:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Permissions", wireType)
|
|
}
|
|
m.Permissions = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Permissions |= ACLChange_UserPermissions(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipAclchanges(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if (skippy < 0) || (iNdEx+skippy) < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *ACLChange_UserConfirm) Unmarshal(dAtA []byte) error {
|
|
l := len(dAtA)
|
|
iNdEx := 0
|
|
for iNdEx < l {
|
|
preIndex := iNdEx
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
wire |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
fieldNum := int32(wire >> 3)
|
|
wireType := int(wire & 0x7)
|
|
if wireType == 4 {
|
|
return fmt.Errorf("proto: UserConfirm: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: UserConfirm: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Identity", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Identity = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field UserAddId", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.UserAddId = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipAclchanges(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if (skippy < 0) || (iNdEx+skippy) < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *ACLChange_UserInvite) Unmarshal(dAtA []byte) error {
|
|
l := len(dAtA)
|
|
iNdEx := 0
|
|
for iNdEx < l {
|
|
preIndex := iNdEx
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
wire |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
fieldNum := int32(wire >> 3)
|
|
wireType := int(wire & 0x7)
|
|
if wireType == 4 {
|
|
return fmt.Errorf("proto: UserInvite: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: UserInvite: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field AcceptPublicKey", wireType)
|
|
}
|
|
var byteLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
byteLen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if byteLen < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
postIndex := iNdEx + byteLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.AcceptPublicKey = append(m.AcceptPublicKey[:0], dAtA[iNdEx:postIndex]...)
|
|
if m.AcceptPublicKey == nil {
|
|
m.AcceptPublicKey = []byte{}
|
|
}
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field EncryptPublicKey", wireType)
|
|
}
|
|
var byteLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
byteLen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if byteLen < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
postIndex := iNdEx + byteLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.EncryptPublicKey = append(m.EncryptPublicKey[:0], dAtA[iNdEx:postIndex]...)
|
|
if m.EncryptPublicKey == nil {
|
|
m.EncryptPublicKey = []byte{}
|
|
}
|
|
iNdEx = postIndex
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field EncryptedReadKeys", wireType)
|
|
}
|
|
var byteLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
byteLen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if byteLen < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
postIndex := iNdEx + byteLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.EncryptedReadKeys = append(m.EncryptedReadKeys, make([]byte, postIndex-iNdEx))
|
|
copy(m.EncryptedReadKeys[len(m.EncryptedReadKeys)-1], dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 4:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Permissions", wireType)
|
|
}
|
|
m.Permissions = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Permissions |= ACLChange_UserPermissions(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 5:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field InviteId", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.InviteId = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipAclchanges(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if (skippy < 0) || (iNdEx+skippy) < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *ACLChange_UserJoin) Unmarshal(dAtA []byte) error {
|
|
l := len(dAtA)
|
|
iNdEx := 0
|
|
for iNdEx < l {
|
|
preIndex := iNdEx
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
wire |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
fieldNum := int32(wire >> 3)
|
|
wireType := int(wire & 0x7)
|
|
if wireType == 4 {
|
|
return fmt.Errorf("proto: UserJoin: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: UserJoin: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Identity", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Identity = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field EncryptionKey", wireType)
|
|
}
|
|
var byteLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
byteLen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if byteLen < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
postIndex := iNdEx + byteLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.EncryptionKey = append(m.EncryptionKey[:0], dAtA[iNdEx:postIndex]...)
|
|
if m.EncryptionKey == nil {
|
|
m.EncryptionKey = []byte{}
|
|
}
|
|
iNdEx = postIndex
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field AcceptSignature", wireType)
|
|
}
|
|
var byteLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
byteLen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if byteLen < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
postIndex := iNdEx + byteLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.AcceptSignature = append(m.AcceptSignature[:0], dAtA[iNdEx:postIndex]...)
|
|
if m.AcceptSignature == nil {
|
|
m.AcceptSignature = []byte{}
|
|
}
|
|
iNdEx = postIndex
|
|
case 4:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field UserInviteId", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.UserInviteId = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 5:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field EncryptedReadKeys", wireType)
|
|
}
|
|
var byteLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
byteLen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if byteLen < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
postIndex := iNdEx + byteLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.EncryptedReadKeys = append(m.EncryptedReadKeys, make([]byte, postIndex-iNdEx))
|
|
copy(m.EncryptedReadKeys[len(m.EncryptedReadKeys)-1], dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipAclchanges(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if (skippy < 0) || (iNdEx+skippy) < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *ACLChange_UserRemove) Unmarshal(dAtA []byte) error {
|
|
l := len(dAtA)
|
|
iNdEx := 0
|
|
for iNdEx < l {
|
|
preIndex := iNdEx
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
wire |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
fieldNum := int32(wire >> 3)
|
|
wireType := int(wire & 0x7)
|
|
if wireType == 4 {
|
|
return fmt.Errorf("proto: UserRemove: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: UserRemove: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Identity", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Identity = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field ReadKeyReplaces", wireType)
|
|
}
|
|
var msglen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
msglen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if msglen < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
postIndex := iNdEx + msglen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.ReadKeyReplaces = append(m.ReadKeyReplaces, &ACLChange_ReadKeyReplace{})
|
|
if err := m.ReadKeyReplaces[len(m.ReadKeyReplaces)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
|
return err
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipAclchanges(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if (skippy < 0) || (iNdEx+skippy) < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *ACLChange_ReadKeyReplace) Unmarshal(dAtA []byte) error {
|
|
l := len(dAtA)
|
|
iNdEx := 0
|
|
for iNdEx < l {
|
|
preIndex := iNdEx
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
wire |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
fieldNum := int32(wire >> 3)
|
|
wireType := int(wire & 0x7)
|
|
if wireType == 4 {
|
|
return fmt.Errorf("proto: ReadKeyReplace: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: ReadKeyReplace: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Identity", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Identity = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field EncryptionKey", wireType)
|
|
}
|
|
var byteLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
byteLen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if byteLen < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
postIndex := iNdEx + byteLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.EncryptionKey = append(m.EncryptionKey[:0], dAtA[iNdEx:postIndex]...)
|
|
if m.EncryptionKey == nil {
|
|
m.EncryptionKey = []byte{}
|
|
}
|
|
iNdEx = postIndex
|
|
case 3:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field EncryptedReadKey", wireType)
|
|
}
|
|
var byteLen int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
byteLen |= int(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if byteLen < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
postIndex := iNdEx + byteLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.EncryptedReadKey = append(m.EncryptedReadKey[:0], dAtA[iNdEx:postIndex]...)
|
|
if m.EncryptedReadKey == nil {
|
|
m.EncryptedReadKey = []byte{}
|
|
}
|
|
iNdEx = postIndex
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipAclchanges(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if (skippy < 0) || (iNdEx+skippy) < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func (m *ACLChange_UserPermissionChange) Unmarshal(dAtA []byte) error {
|
|
l := len(dAtA)
|
|
iNdEx := 0
|
|
for iNdEx < l {
|
|
preIndex := iNdEx
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
wire |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
fieldNum := int32(wire >> 3)
|
|
wireType := int(wire & 0x7)
|
|
if wireType == 4 {
|
|
return fmt.Errorf("proto: UserPermissionChange: wiretype end group for non-group")
|
|
}
|
|
if fieldNum <= 0 {
|
|
return fmt.Errorf("proto: UserPermissionChange: illegal tag %d (wire type %d)", fieldNum, wire)
|
|
}
|
|
switch fieldNum {
|
|
case 1:
|
|
if wireType != 2 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Identity", wireType)
|
|
}
|
|
var stringLen uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
stringLen |= uint64(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
intStringLen := int(stringLen)
|
|
if intStringLen < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
postIndex := iNdEx + intStringLen
|
|
if postIndex < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if postIndex > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
m.Identity = string(dAtA[iNdEx:postIndex])
|
|
iNdEx = postIndex
|
|
case 2:
|
|
if wireType != 0 {
|
|
return fmt.Errorf("proto: wrong wireType = %d for field Permissions", wireType)
|
|
}
|
|
m.Permissions = 0
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
m.Permissions |= ACLChange_UserPermissions(b&0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
default:
|
|
iNdEx = preIndex
|
|
skippy, err := skipAclchanges(dAtA[iNdEx:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if (skippy < 0) || (iNdEx+skippy) < 0 {
|
|
return ErrInvalidLengthAclchanges
|
|
}
|
|
if (iNdEx + skippy) > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx += skippy
|
|
}
|
|
}
|
|
|
|
if iNdEx > l {
|
|
return io.ErrUnexpectedEOF
|
|
}
|
|
return nil
|
|
}
|
|
func skipAclchanges(dAtA []byte) (n int, err error) {
|
|
l := len(dAtA)
|
|
iNdEx := 0
|
|
depth := 0
|
|
for iNdEx < l {
|
|
var wire uint64
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return 0, ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return 0, io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
wire |= (uint64(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
wireType := int(wire & 0x7)
|
|
switch wireType {
|
|
case 0:
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return 0, ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return 0, io.ErrUnexpectedEOF
|
|
}
|
|
iNdEx++
|
|
if dAtA[iNdEx-1] < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
case 1:
|
|
iNdEx += 8
|
|
case 2:
|
|
var length int
|
|
for shift := uint(0); ; shift += 7 {
|
|
if shift >= 64 {
|
|
return 0, ErrIntOverflowAclchanges
|
|
}
|
|
if iNdEx >= l {
|
|
return 0, io.ErrUnexpectedEOF
|
|
}
|
|
b := dAtA[iNdEx]
|
|
iNdEx++
|
|
length |= (int(b) & 0x7F) << shift
|
|
if b < 0x80 {
|
|
break
|
|
}
|
|
}
|
|
if length < 0 {
|
|
return 0, ErrInvalidLengthAclchanges
|
|
}
|
|
iNdEx += length
|
|
case 3:
|
|
depth++
|
|
case 4:
|
|
if depth == 0 {
|
|
return 0, ErrUnexpectedEndOfGroupAclchanges
|
|
}
|
|
depth--
|
|
case 5:
|
|
iNdEx += 4
|
|
default:
|
|
return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
|
|
}
|
|
if iNdEx < 0 {
|
|
return 0, ErrInvalidLengthAclchanges
|
|
}
|
|
if depth == 0 {
|
|
return iNdEx, nil
|
|
}
|
|
}
|
|
return 0, io.ErrUnexpectedEOF
|
|
}
|
|
|
|
var (
|
|
ErrInvalidLengthAclchanges = fmt.Errorf("proto: negative length found during unmarshaling")
|
|
ErrIntOverflowAclchanges = fmt.Errorf("proto: integer overflow")
|
|
ErrUnexpectedEndOfGroupAclchanges = fmt.Errorf("proto: unexpected end of group")
|
|
)
|