Add space and document creation logic for client
This commit is contained in:
mcrakhman
Mikhail Iudin
parent
2c9f54464a
commit
42e0c50540
4
.fleet/settings.json
Normal file
4
.fleet/settings.json
Normal file
@ -0,0 +1,4 @@
|
||||
{
|
||||
"toolchains": [],
|
||||
"editor.guides": []
|
||||
}
|
||||
@ -3,9 +3,10 @@ package clientcache
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"github.com/anytypeio/go-anytype-infrastructure-experiments/client/clientspace"
|
||||
"github.com/anytypeio/go-anytype-infrastructure-experiments/client/document"
|
||||
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app"
|
||||
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app/logger"
|
||||
"github.com/anytypeio/go-anytype-infrastructure-experiments/client/clientspace"
|
||||
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/cache"
|
||||
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/ocache"
|
||||
"time"
|
||||
@ -21,6 +22,7 @@ const spaceKey ctxKey = 0
|
||||
type treeCache struct {
|
||||
gcttl int
|
||||
cache ocache.OCache
|
||||
docService document.Service
|
||||
clientService clientspace.Service
|
||||
}
|
||||
|
||||
@ -40,14 +42,16 @@ func (c *treeCache) Close(ctx context.Context) (err error) {
|
||||
|
||||
func (c *treeCache) Init(a *app.App) (err error) {
|
||||
c.clientService = a.MustComponent(clientspace.CName).(clientspace.Service)
|
||||
c.docService = a.MustComponent(document.CName).(document.Service)
|
||||
c.cache = ocache.New(
|
||||
func(ctx context.Context, id string) (value ocache.Object, err error) {
|
||||
spaceId := ctx.Value(spaceKey).(string)
|
||||
space, err := c.clientService.GetSpace(ctx, spaceId)
|
||||
container, err := c.clientService.GetSpace(ctx, spaceId)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
return space.BuildTree(ctx, id, nil)
|
||||
defer container.Release()
|
||||
return document.NewTextDocument(context.Background(), container.Object, id, c.docService)
|
||||
},
|
||||
ocache.WithLogger(log.Sugar()),
|
||||
ocache.WithGCPeriod(time.Minute),
|
||||
|
||||
@ -2,6 +2,7 @@ package clientspace
|
||||
|
||||
import (
|
||||
"context"
|
||||
"github.com/anytypeio/go-anytype-infrastructure-experiments/client/util"
|
||||
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app"
|
||||
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app/logger"
|
||||
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace"
|
||||
@ -22,9 +23,9 @@ func New() Service {
|
||||
}
|
||||
|
||||
type Service interface {
|
||||
GetSpace(ctx context.Context, id string) (commonspace.Space, error)
|
||||
CreateSpace(ctx context.Context, payload commonspace.SpaceCreatePayload) (commonspace.Space, error)
|
||||
DeriveSpace(ctx context.Context, payload commonspace.SpaceDerivePayload) (commonspace.Space, error)
|
||||
GetSpace(ctx context.Context, id string) (util.ReleaseContainer[commonspace.Space], error)
|
||||
CreateSpace(ctx context.Context, payload commonspace.SpaceCreatePayload) (util.ReleaseContainer[commonspace.Space], error)
|
||||
DeriveSpace(ctx context.Context, payload commonspace.SpaceDerivePayload) (util.ReleaseContainer[commonspace.Space], error)
|
||||
app.ComponentRunnable
|
||||
}
|
||||
|
||||
@ -63,38 +64,53 @@ func (s *service) Run(ctx context.Context) (err error) {
|
||||
return
|
||||
}
|
||||
|
||||
func (s *service) CreateSpace(ctx context.Context, payload commonspace.SpaceCreatePayload) (space commonspace.Space, err error) {
|
||||
func (s *service) CreateSpace(ctx context.Context, payload commonspace.SpaceCreatePayload) (container util.ReleaseContainer[commonspace.Space], err error) {
|
||||
id, err := s.commonSpace.CreateSpace(ctx, payload)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
obj, err := s.commonSpace.GetSpace(ctx, id)
|
||||
obj, err := s.spaceCache.Get(ctx, id)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
return obj.(commonspace.Space), nil
|
||||
return util.ReleaseContainer[commonspace.Space]{
|
||||
Object: obj.(commonspace.Space),
|
||||
Release: func() {
|
||||
s.spaceCache.Release(id)
|
||||
},
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (s *service) DeriveSpace(ctx context.Context, payload commonspace.SpaceDerivePayload) (space commonspace.Space, err error) {
|
||||
func (s *service) DeriveSpace(ctx context.Context, payload commonspace.SpaceDerivePayload) (container util.ReleaseContainer[commonspace.Space], err error) {
|
||||
id, err := s.commonSpace.DeriveSpace(ctx, payload)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
obj, err := s.commonSpace.GetSpace(ctx, id)
|
||||
obj, err := s.spaceCache.Get(ctx, id)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
return obj.(commonspace.Space), nil
|
||||
return util.ReleaseContainer[commonspace.Space]{
|
||||
Object: obj.(commonspace.Space),
|
||||
Release: func() {
|
||||
s.spaceCache.Release(id)
|
||||
},
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (s *service) GetSpace(ctx context.Context, id string) (commonspace.Space, error) {
|
||||
func (s *service) GetSpace(ctx context.Context, id string) (container util.ReleaseContainer[commonspace.Space], err error) {
|
||||
v, err := s.spaceCache.Get(ctx, id)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
return
|
||||
}
|
||||
return v.(commonspace.Space), nil
|
||||
return util.ReleaseContainer[commonspace.Space]{
|
||||
Object: v.(commonspace.Space),
|
||||
Release: func() {
|
||||
s.spaceCache.Release(id)
|
||||
},
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (s *service) Close(ctx context.Context) (err error) {
|
||||
|
||||
@ -1,13 +1,97 @@
|
||||
package document
|
||||
|
||||
import "github.com/anytypeio/go-anytype-infrastructure-experiments/common/app"
|
||||
import (
|
||||
"context"
|
||||
"github.com/anytypeio/go-anytype-infrastructure-experiments/client/clientspace"
|
||||
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/account"
|
||||
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app"
|
||||
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/app/logger"
|
||||
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/cache"
|
||||
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/synctree/updatelistener"
|
||||
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/tree"
|
||||
)
|
||||
|
||||
type Service interface {
|
||||
app.Component
|
||||
updatelistener.UpdateListener
|
||||
CreateDocument(spaceId string) (id string, err error)
|
||||
GetAllDocumentIds(spaceId string) (ids []string, err error)
|
||||
AddText(documentId, text string) (err error)
|
||||
DumpDocumentTree(documentId string) (err error)
|
||||
AddText(spaceId, documentId, text string) (err error)
|
||||
DumpDocumentTree(spaceId, documentId string) (dump string, err error)
|
||||
}
|
||||
|
||||
const CName = "client.document"
|
||||
|
||||
var log = logger.NewNamed(CName)
|
||||
|
||||
type service struct {
|
||||
account account.Service
|
||||
spaceService clientspace.Service
|
||||
cache cache.TreeCache
|
||||
}
|
||||
|
||||
func New() Service {
|
||||
return &service{}
|
||||
}
|
||||
|
||||
func (s *service) Init(a *app.App) (err error) {
|
||||
s.account = a.MustComponent(account.CName).(account.Service)
|
||||
s.spaceService = a.MustComponent(clientspace.CName).(clientspace.Service)
|
||||
s.cache = a.MustComponent(cache.CName).(cache.TreeCache)
|
||||
return
|
||||
}
|
||||
|
||||
func (s *service) Name() (name string) {
|
||||
return CName
|
||||
}
|
||||
|
||||
func (s *service) CreateDocument(spaceId string) (id string, err error) {
|
||||
spaceRef, err := s.spaceService.GetSpace(context.Background(), spaceId)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
defer spaceRef.Release()
|
||||
doc, err := createTextDocument(context.Background(), spaceRef.Object, s.account, s)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
id = doc.Tree().ID()
|
||||
return
|
||||
}
|
||||
|
||||
func (s *service) GetAllDocumentIds(spaceId string) (ids []string, err error) {
|
||||
spaceRef, err := s.spaceService.GetSpace(context.Background(), spaceId)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
defer spaceRef.Release()
|
||||
ids = spaceRef.Object.StoredIds()
|
||||
return
|
||||
}
|
||||
|
||||
func (s *service) AddText(spaceId, documentId, text string) (err error) {
|
||||
doc, err := s.cache.GetTree(context.Background(), spaceId, documentId)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
defer doc.Release()
|
||||
return doc.TreeContainer.(TextDocument).AddText(text)
|
||||
}
|
||||
|
||||
func (s *service) DumpDocumentTree(spaceId, documentId string) (dump string, err error) {
|
||||
doc, err := s.cache.GetTree(context.Background(), spaceId, documentId)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
defer doc.Release()
|
||||
return doc.TreeContainer.Tree().DebugDump()
|
||||
}
|
||||
|
||||
func (s *service) Update(tree tree.ObjectTree) {
|
||||
|
||||
}
|
||||
|
||||
func (s *service) Rebuild(tree tree.ObjectTree) {
|
||||
//TODO implement me
|
||||
panic("implement me")
|
||||
}
|
||||
|
||||
114
client/document/textdocument.go
Normal file
114
client/document/textdocument.go
Normal file
@ -0,0 +1,114 @@
|
||||
package document
|
||||
|
||||
import (
|
||||
"context"
|
||||
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/account"
|
||||
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace"
|
||||
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/cache"
|
||||
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/commonspace/synctree/updatelistener"
|
||||
testchanges "github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/testutils/testchanges/proto"
|
||||
"github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/acl/tree"
|
||||
"github.com/gogo/protobuf/proto"
|
||||
)
|
||||
|
||||
type TextDocument interface {
|
||||
cache.TreeContainer
|
||||
AddText(text string) error
|
||||
Text() (string, error)
|
||||
TreeDump() string
|
||||
Close() error
|
||||
}
|
||||
|
||||
type textDocument struct {
|
||||
objTree tree.ObjectTree
|
||||
account account.Service
|
||||
}
|
||||
|
||||
func createTextDocument(
|
||||
ctx context.Context,
|
||||
space commonspace.Space,
|
||||
account account.Service,
|
||||
listener updatelistener.UpdateListener) (doc TextDocument, err error) {
|
||||
payload := tree.ObjectTreeCreatePayload{
|
||||
SignKey: account.Account().SignKey,
|
||||
SpaceId: space.Id(),
|
||||
Identity: account.Account().Identity,
|
||||
}
|
||||
t, err := space.CreateTree(ctx, payload, listener)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
return &textDocument{
|
||||
objTree: t,
|
||||
}, nil
|
||||
}
|
||||
|
||||
func NewTextDocument(ctx context.Context, space commonspace.Space, id string, listener updatelistener.UpdateListener) (doc TextDocument, err error) {
|
||||
t, err := space.BuildTree(ctx, id, listener)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
return &textDocument{
|
||||
objTree: t,
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (t *textDocument) Tree() tree.ObjectTree {
|
||||
return t.objTree
|
||||
}
|
||||
|
||||
func (t *textDocument) AddText(text string) (err error) {
|
||||
content := &testchanges.TextContentValueOfTextAppend{
|
||||
TextAppend: &testchanges.TextAppend{Text: text},
|
||||
}
|
||||
change := &testchanges.TextData{
|
||||
Content: []*testchanges.TextContent{
|
||||
{content},
|
||||
},
|
||||
Snapshot: nil,
|
||||
}
|
||||
res, err := change.Marshal()
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
_, err = t.objTree.AddContent(context.Background(), tree.SignableChangeContent{
|
||||
Data: res,
|
||||
Key: t.account.Account().SignKey,
|
||||
Identity: t.account.Account().Identity,
|
||||
IsSnapshot: false,
|
||||
})
|
||||
return
|
||||
}
|
||||
|
||||
func (t *textDocument) Text() (text string, err error) {
|
||||
t.objTree.RLock()
|
||||
defer t.objTree.RUnlock()
|
||||
|
||||
err = t.objTree.Iterate(
|
||||
func(decrypted []byte) (any, error) {
|
||||
textChange := &testchanges.TextData{}
|
||||
err = proto.Unmarshal(decrypted, textChange)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
for _, cnt := range textChange.Content {
|
||||
if cnt.GetTextAppend() != nil {
|
||||
text += cnt.GetTextAppend().Text
|
||||
}
|
||||
}
|
||||
return textChange, nil
|
||||
}, func(change *tree.Change) bool {
|
||||
return true
|
||||
})
|
||||
return
|
||||
}
|
||||
|
||||
func (t *textDocument) TreeDump() string {
|
||||
return t.TreeDump()
|
||||
}
|
||||
|
||||
func (t *textDocument) Close() error {
|
||||
return nil
|
||||
}
|
||||
@ -2,10 +2,70 @@ module github.com/anytypeio/go-anytype-infrastructure-experiments/client
|
||||
|
||||
replace github.com/anytypeio/go-anytype-infrastructure-experiments/common => ../common
|
||||
|
||||
|
||||
go 1.19
|
||||
|
||||
require (
|
||||
github.com/anytypeio/go-anytype-infrastructure-experiments/common v0.0.0-00010101000000-000000000000
|
||||
github.com/dgraph-io/badger/v3 v3.2103.3
|
||||
github.com/gogo/protobuf v1.3.2
|
||||
)
|
||||
|
||||
require (
|
||||
github.com/anytypeio/go-chash v0.0.0-20220629194632-4ad1154fe232 // indirect
|
||||
github.com/beorn7/perks v1.0.1 // indirect
|
||||
github.com/cespare/xxhash v1.1.0 // indirect
|
||||
github.com/cespare/xxhash/v2 v2.1.2 // indirect
|
||||
github.com/decred/dcrd/dcrec/secp256k1/v4 v4.1.0 // indirect
|
||||
github.com/dgraph-io/ristretto v0.1.1 // indirect
|
||||
github.com/dustin/go-humanize v1.0.0 // indirect
|
||||
github.com/fogleman/gg v1.3.0 // indirect
|
||||
github.com/goccy/go-graphviz v0.0.9 // indirect
|
||||
github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0 // indirect
|
||||
github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b // indirect
|
||||
github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e // indirect
|
||||
github.com/golang/protobuf v1.5.2 // indirect
|
||||
github.com/golang/snappy v0.0.3 // indirect
|
||||
github.com/google/flatbuffers v1.12.1 // indirect
|
||||
github.com/huandu/skiplist v1.2.0 // indirect
|
||||
github.com/ipfs/go-cid v0.3.2 // indirect
|
||||
github.com/ipfs/go-log/v2 v2.5.1 // indirect
|
||||
github.com/klauspost/compress v1.15.10 // indirect
|
||||
github.com/klauspost/cpuid/v2 v2.1.1 // indirect
|
||||
github.com/libp2p/go-buffer-pool v0.1.0 // indirect
|
||||
github.com/libp2p/go-libp2p v0.23.2 // indirect
|
||||
github.com/libp2p/go-libp2p-core v0.20.1 // indirect
|
||||
github.com/libp2p/go-openssl v0.1.0 // indirect
|
||||
github.com/mattn/go-isatty v0.0.16 // indirect
|
||||
github.com/mattn/go-pointer v0.0.1 // indirect
|
||||
github.com/matttproud/golang_protobuf_extensions v1.0.1 // indirect
|
||||
github.com/minio/sha256-simd v1.0.0 // indirect
|
||||
github.com/mr-tron/base58 v1.2.0 // indirect
|
||||
github.com/multiformats/go-base32 v0.1.0 // indirect
|
||||
github.com/multiformats/go-base36 v0.1.0 // indirect
|
||||
github.com/multiformats/go-multiaddr v0.7.0 // indirect
|
||||
github.com/multiformats/go-multibase v0.1.1 // indirect
|
||||
github.com/multiformats/go-multicodec v0.6.0 // indirect
|
||||
github.com/multiformats/go-multihash v0.2.1 // indirect
|
||||
github.com/multiformats/go-varint v0.0.6 // indirect
|
||||
github.com/pkg/errors v0.9.1 // indirect
|
||||
github.com/prometheus/client_golang v1.13.0 // indirect
|
||||
github.com/prometheus/client_model v0.2.0 // indirect
|
||||
github.com/prometheus/common v0.37.0 // indirect
|
||||
github.com/prometheus/procfs v0.8.0 // indirect
|
||||
github.com/spacemonkeygo/spacelog v0.0.0-20180420211403-2296661a0572 // indirect
|
||||
github.com/spaolacci/murmur3 v1.1.0 // indirect
|
||||
github.com/zeebo/blake3 v0.2.3 // indirect
|
||||
github.com/zeebo/errs v1.3.0 // indirect
|
||||
go.opencensus.io v0.23.0 // indirect
|
||||
go.uber.org/atomic v1.10.0 // indirect
|
||||
go.uber.org/multierr v1.8.0 // indirect
|
||||
go.uber.org/zap v1.23.0 // indirect
|
||||
golang.org/x/crypto v0.0.0-20220525230936-793ad666bf5e // indirect
|
||||
golang.org/x/image v0.0.0-20200119044424-58c23975cae1 // indirect
|
||||
golang.org/x/net v0.0.0-20220920183852-bf014ff85ad5 // indirect
|
||||
golang.org/x/sys v0.0.0-20221010170243-090e33056c14 // indirect
|
||||
google.golang.org/protobuf v1.28.1 // indirect
|
||||
gopkg.in/yaml.v3 v3.0.1 // indirect
|
||||
lukechampine.com/blake3 v1.1.7 // indirect
|
||||
storj.io/drpc v0.0.32 // indirect
|
||||
)
|
||||
|
||||
6
client/util/releasecontainer.go
Normal file
6
client/util/releasecontainer.go
Normal file
@ -0,0 +1,6 @@
|
||||
package util
|
||||
|
||||
type ReleaseContainer[T any] struct {
|
||||
Object T
|
||||
Release func()
|
||||
}
|
||||
@ -17,6 +17,7 @@ type DiffService interface {
|
||||
HandleRangeRequest(ctx context.Context, req *spacesyncproto.HeadSyncRequest) (resp *spacesyncproto.HeadSyncResponse, err error)
|
||||
UpdateHeads(id string, heads []string)
|
||||
RemoveObject(id string)
|
||||
AllIds() []string
|
||||
|
||||
Init(objectIds []string)
|
||||
Close() (err error)
|
||||
@ -72,6 +73,10 @@ func (d *diffService) UpdateHeads(id string, heads []string) {
|
||||
})
|
||||
}
|
||||
|
||||
func (d *diffService) AllIds() []string {
|
||||
return d.diff.Ids()
|
||||
}
|
||||
|
||||
func (d *diffService) RemoveObject(id string) {
|
||||
// TODO: add space document to remove ids
|
||||
d.diff.RemoveId(id)
|
||||
|
||||
@ -44,6 +44,7 @@ func NewSpaceId(id string, repKey uint64) string {
|
||||
|
||||
type Space interface {
|
||||
Id() string
|
||||
StoredIds() []string
|
||||
|
||||
SpaceSyncRpc() RpcHandler
|
||||
|
||||
@ -94,6 +95,10 @@ func (s *space) DiffService() diffservice.DiffService {
|
||||
return s.diffService
|
||||
}
|
||||
|
||||
func (s *space) StoredIds() []string {
|
||||
return s.diffService.AllIds()
|
||||
}
|
||||
|
||||
func (s *space) DeriveTree(ctx context.Context, payload tree2.ObjectTreeCreatePayload, listener updatelistener.UpdateListener) (tree2.ObjectTree, error) {
|
||||
return synctree.DeriveSyncTree(ctx, payload, s.syncService.SyncClient(), listener, s.aclList, s.storage.CreateTreeStorage)
|
||||
}
|
||||
|
||||
@ -408,11 +408,11 @@ func (m *ObjectSyncMessage) GetTrackingId() string {
|
||||
// ObjectSyncContentValue provides different types for object sync
|
||||
type ObjectSyncContentValue struct {
|
||||
// Types that are valid to be assigned to Value:
|
||||
// *ObjectSyncContentValue_HeadUpdate
|
||||
// *ObjectSyncContentValue_FullSyncRequest
|
||||
// *ObjectSyncContentValue_FullSyncResponse
|
||||
// *ObjectSyncContentValue_ErrorResponse
|
||||
Value isObjectSyncContentValue_Value `protobuf_oneof:"value"`
|
||||
// *ObjectSyncContentValueValueOfHeadUpdate
|
||||
// *ObjectSyncContentValueValueOfFullSyncRequest
|
||||
// *ObjectSyncContentValueValueOfFullSyncResponse
|
||||
// *ObjectSyncContentValueValueOfErrorResponse
|
||||
Value IsObjectSyncContentValueValue `protobuf_oneof:"value"`
|
||||
}
|
||||
|
||||
func (m *ObjectSyncContentValue) Reset() { *m = ObjectSyncContentValue{} }
|
||||
@ -448,31 +448,31 @@ func (m *ObjectSyncContentValue) XXX_DiscardUnknown() {
|
||||
|
||||
var xxx_messageInfo_ObjectSyncContentValue proto.InternalMessageInfo
|
||||
|
||||
type isObjectSyncContentValue_Value interface {
|
||||
isObjectSyncContentValue_Value()
|
||||
type IsObjectSyncContentValueValue interface {
|
||||
IsObjectSyncContentValueValue()
|
||||
MarshalTo([]byte) (int, error)
|
||||
Size() int
|
||||
}
|
||||
|
||||
type ObjectSyncContentValue_HeadUpdate struct {
|
||||
type ObjectSyncContentValueValueOfHeadUpdate struct {
|
||||
HeadUpdate *ObjectHeadUpdate `protobuf:"bytes,1,opt,name=headUpdate,proto3,oneof" json:"headUpdate,omitempty"`
|
||||
}
|
||||
type ObjectSyncContentValue_FullSyncRequest struct {
|
||||
type ObjectSyncContentValueValueOfFullSyncRequest struct {
|
||||
FullSyncRequest *ObjectFullSyncRequest `protobuf:"bytes,2,opt,name=fullSyncRequest,proto3,oneof" json:"fullSyncRequest,omitempty"`
|
||||
}
|
||||
type ObjectSyncContentValue_FullSyncResponse struct {
|
||||
type ObjectSyncContentValueValueOfFullSyncResponse struct {
|
||||
FullSyncResponse *ObjectFullSyncResponse `protobuf:"bytes,3,opt,name=fullSyncResponse,proto3,oneof" json:"fullSyncResponse,omitempty"`
|
||||
}
|
||||
type ObjectSyncContentValue_ErrorResponse struct {
|
||||
type ObjectSyncContentValueValueOfErrorResponse struct {
|
||||
ErrorResponse *ObjectErrorResponse `protobuf:"bytes,4,opt,name=errorResponse,proto3,oneof" json:"errorResponse,omitempty"`
|
||||
}
|
||||
|
||||
func (*ObjectSyncContentValue_HeadUpdate) isObjectSyncContentValue_Value() {}
|
||||
func (*ObjectSyncContentValue_FullSyncRequest) isObjectSyncContentValue_Value() {}
|
||||
func (*ObjectSyncContentValue_FullSyncResponse) isObjectSyncContentValue_Value() {}
|
||||
func (*ObjectSyncContentValue_ErrorResponse) isObjectSyncContentValue_Value() {}
|
||||
func (*ObjectSyncContentValueValueOfHeadUpdate) IsObjectSyncContentValueValue() {}
|
||||
func (*ObjectSyncContentValueValueOfFullSyncRequest) IsObjectSyncContentValueValue() {}
|
||||
func (*ObjectSyncContentValueValueOfFullSyncResponse) IsObjectSyncContentValueValue() {}
|
||||
func (*ObjectSyncContentValueValueOfErrorResponse) IsObjectSyncContentValueValue() {}
|
||||
|
||||
func (m *ObjectSyncContentValue) GetValue() isObjectSyncContentValue_Value {
|
||||
func (m *ObjectSyncContentValue) GetValue() IsObjectSyncContentValueValue {
|
||||
if m != nil {
|
||||
return m.Value
|
||||
}
|
||||
@ -480,28 +480,28 @@ func (m *ObjectSyncContentValue) GetValue() isObjectSyncContentValue_Value {
|
||||
}
|
||||
|
||||
func (m *ObjectSyncContentValue) GetHeadUpdate() *ObjectHeadUpdate {
|
||||
if x, ok := m.GetValue().(*ObjectSyncContentValue_HeadUpdate); ok {
|
||||
if x, ok := m.GetValue().(*ObjectSyncContentValueValueOfHeadUpdate); ok {
|
||||
return x.HeadUpdate
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *ObjectSyncContentValue) GetFullSyncRequest() *ObjectFullSyncRequest {
|
||||
if x, ok := m.GetValue().(*ObjectSyncContentValue_FullSyncRequest); ok {
|
||||
if x, ok := m.GetValue().(*ObjectSyncContentValueValueOfFullSyncRequest); ok {
|
||||
return x.FullSyncRequest
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *ObjectSyncContentValue) GetFullSyncResponse() *ObjectFullSyncResponse {
|
||||
if x, ok := m.GetValue().(*ObjectSyncContentValue_FullSyncResponse); ok {
|
||||
if x, ok := m.GetValue().(*ObjectSyncContentValueValueOfFullSyncResponse); ok {
|
||||
return x.FullSyncResponse
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *ObjectSyncContentValue) GetErrorResponse() *ObjectErrorResponse {
|
||||
if x, ok := m.GetValue().(*ObjectSyncContentValue_ErrorResponse); ok {
|
||||
if x, ok := m.GetValue().(*ObjectSyncContentValueValueOfErrorResponse); ok {
|
||||
return x.ErrorResponse
|
||||
}
|
||||
return nil
|
||||
@ -510,10 +510,10 @@ func (m *ObjectSyncContentValue) GetErrorResponse() *ObjectErrorResponse {
|
||||
// XXX_OneofWrappers is for the internal use of the proto package.
|
||||
func (*ObjectSyncContentValue) XXX_OneofWrappers() []interface{} {
|
||||
return []interface{}{
|
||||
(*ObjectSyncContentValue_HeadUpdate)(nil),
|
||||
(*ObjectSyncContentValue_FullSyncRequest)(nil),
|
||||
(*ObjectSyncContentValue_FullSyncResponse)(nil),
|
||||
(*ObjectSyncContentValue_ErrorResponse)(nil),
|
||||
(*ObjectSyncContentValueValueOfHeadUpdate)(nil),
|
||||
(*ObjectSyncContentValueValueOfFullSyncRequest)(nil),
|
||||
(*ObjectSyncContentValueValueOfFullSyncResponse)(nil),
|
||||
(*ObjectSyncContentValueValueOfErrorResponse)(nil),
|
||||
}
|
||||
}
|
||||
|
||||
@ -1410,12 +1410,12 @@ func (m *ObjectSyncContentValue) MarshalToSizedBuffer(dAtA []byte) (int, error)
|
||||
return len(dAtA) - i, nil
|
||||
}
|
||||
|
||||
func (m *ObjectSyncContentValue_HeadUpdate) MarshalTo(dAtA []byte) (int, error) {
|
||||
func (m *ObjectSyncContentValueValueOfHeadUpdate) MarshalTo(dAtA []byte) (int, error) {
|
||||
size := m.Size()
|
||||
return m.MarshalToSizedBuffer(dAtA[:size])
|
||||
}
|
||||
|
||||
func (m *ObjectSyncContentValue_HeadUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||||
func (m *ObjectSyncContentValueValueOfHeadUpdate) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||||
i := len(dAtA)
|
||||
if m.HeadUpdate != nil {
|
||||
{
|
||||
@ -1431,12 +1431,12 @@ func (m *ObjectSyncContentValue_HeadUpdate) MarshalToSizedBuffer(dAtA []byte) (i
|
||||
}
|
||||
return len(dAtA) - i, nil
|
||||
}
|
||||
func (m *ObjectSyncContentValue_FullSyncRequest) MarshalTo(dAtA []byte) (int, error) {
|
||||
func (m *ObjectSyncContentValueValueOfFullSyncRequest) MarshalTo(dAtA []byte) (int, error) {
|
||||
size := m.Size()
|
||||
return m.MarshalToSizedBuffer(dAtA[:size])
|
||||
}
|
||||
|
||||
func (m *ObjectSyncContentValue_FullSyncRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||||
func (m *ObjectSyncContentValueValueOfFullSyncRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||||
i := len(dAtA)
|
||||
if m.FullSyncRequest != nil {
|
||||
{
|
||||
@ -1452,12 +1452,12 @@ func (m *ObjectSyncContentValue_FullSyncRequest) MarshalToSizedBuffer(dAtA []byt
|
||||
}
|
||||
return len(dAtA) - i, nil
|
||||
}
|
||||
func (m *ObjectSyncContentValue_FullSyncResponse) MarshalTo(dAtA []byte) (int, error) {
|
||||
func (m *ObjectSyncContentValueValueOfFullSyncResponse) MarshalTo(dAtA []byte) (int, error) {
|
||||
size := m.Size()
|
||||
return m.MarshalToSizedBuffer(dAtA[:size])
|
||||
}
|
||||
|
||||
func (m *ObjectSyncContentValue_FullSyncResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||||
func (m *ObjectSyncContentValueValueOfFullSyncResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||||
i := len(dAtA)
|
||||
if m.FullSyncResponse != nil {
|
||||
{
|
||||
@ -1473,12 +1473,12 @@ func (m *ObjectSyncContentValue_FullSyncResponse) MarshalToSizedBuffer(dAtA []by
|
||||
}
|
||||
return len(dAtA) - i, nil
|
||||
}
|
||||
func (m *ObjectSyncContentValue_ErrorResponse) MarshalTo(dAtA []byte) (int, error) {
|
||||
func (m *ObjectSyncContentValueValueOfErrorResponse) MarshalTo(dAtA []byte) (int, error) {
|
||||
size := m.Size()
|
||||
return m.MarshalToSizedBuffer(dAtA[:size])
|
||||
}
|
||||
|
||||
func (m *ObjectSyncContentValue_ErrorResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||||
func (m *ObjectSyncContentValueValueOfErrorResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||||
i := len(dAtA)
|
||||
if m.ErrorResponse != nil {
|
||||
{
|
||||
@ -2030,7 +2030,7 @@ func (m *ObjectSyncContentValue) Size() (n int) {
|
||||
return n
|
||||
}
|
||||
|
||||
func (m *ObjectSyncContentValue_HeadUpdate) Size() (n int) {
|
||||
func (m *ObjectSyncContentValueValueOfHeadUpdate) Size() (n int) {
|
||||
if m == nil {
|
||||
return 0
|
||||
}
|
||||
@ -2042,7 +2042,7 @@ func (m *ObjectSyncContentValue_HeadUpdate) Size() (n int) {
|
||||
}
|
||||
return n
|
||||
}
|
||||
func (m *ObjectSyncContentValue_FullSyncRequest) Size() (n int) {
|
||||
func (m *ObjectSyncContentValueValueOfFullSyncRequest) Size() (n int) {
|
||||
if m == nil {
|
||||
return 0
|
||||
}
|
||||
@ -2054,7 +2054,7 @@ func (m *ObjectSyncContentValue_FullSyncRequest) Size() (n int) {
|
||||
}
|
||||
return n
|
||||
}
|
||||
func (m *ObjectSyncContentValue_FullSyncResponse) Size() (n int) {
|
||||
func (m *ObjectSyncContentValueValueOfFullSyncResponse) Size() (n int) {
|
||||
if m == nil {
|
||||
return 0
|
||||
}
|
||||
@ -2066,7 +2066,7 @@ func (m *ObjectSyncContentValue_FullSyncResponse) Size() (n int) {
|
||||
}
|
||||
return n
|
||||
}
|
||||
func (m *ObjectSyncContentValue_ErrorResponse) Size() (n int) {
|
||||
func (m *ObjectSyncContentValueValueOfErrorResponse) Size() (n int) {
|
||||
if m == nil {
|
||||
return 0
|
||||
}
|
||||
@ -3103,7 +3103,7 @@ func (m *ObjectSyncContentValue) Unmarshal(dAtA []byte) error {
|
||||
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
||||
return err
|
||||
}
|
||||
m.Value = &ObjectSyncContentValue_HeadUpdate{v}
|
||||
m.Value = &ObjectSyncContentValueValueOfHeadUpdate{v}
|
||||
iNdEx = postIndex
|
||||
case 2:
|
||||
if wireType != 2 {
|
||||
@ -3138,7 +3138,7 @@ func (m *ObjectSyncContentValue) Unmarshal(dAtA []byte) error {
|
||||
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
||||
return err
|
||||
}
|
||||
m.Value = &ObjectSyncContentValue_FullSyncRequest{v}
|
||||
m.Value = &ObjectSyncContentValueValueOfFullSyncRequest{v}
|
||||
iNdEx = postIndex
|
||||
case 3:
|
||||
if wireType != 2 {
|
||||
@ -3173,7 +3173,7 @@ func (m *ObjectSyncContentValue) Unmarshal(dAtA []byte) error {
|
||||
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
||||
return err
|
||||
}
|
||||
m.Value = &ObjectSyncContentValue_FullSyncResponse{v}
|
||||
m.Value = &ObjectSyncContentValueValueOfFullSyncResponse{v}
|
||||
iNdEx = postIndex
|
||||
case 4:
|
||||
if wireType != 2 {
|
||||
@ -3208,7 +3208,7 @@ func (m *ObjectSyncContentValue) Unmarshal(dAtA []byte) error {
|
||||
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
||||
return err
|
||||
}
|
||||
m.Value = &ObjectSyncContentValue_ErrorResponse{v}
|
||||
m.Value = &ObjectSyncContentValueValueOfErrorResponse{v}
|
||||
iNdEx = postIndex
|
||||
default:
|
||||
iNdEx = preIndex
|
||||
|
||||
@ -324,13 +324,12 @@ func (m *ACLRoot) GetTimestamp() int64 {
|
||||
|
||||
type ACLContentValue struct {
|
||||
// Types that are valid to be assigned to Value:
|
||||
//
|
||||
// *ACLContentValue_UserAdd
|
||||
// *ACLContentValue_UserRemove
|
||||
// *ACLContentValue_UserPermissionChange
|
||||
// *ACLContentValue_UserInvite
|
||||
// *ACLContentValue_UserJoin
|
||||
Value isACLContentValue_Value `protobuf_oneof:"value"`
|
||||
// *ACLContentValueValueOfUserAdd
|
||||
// *ACLContentValueValueOfUserRemove
|
||||
// *ACLContentValueValueOfUserPermissionChange
|
||||
// *ACLContentValueValueOfUserInvite
|
||||
// *ACLContentValueValueOfUserJoin
|
||||
Value IsACLContentValueValue `protobuf_oneof:"value"`
|
||||
}
|
||||
|
||||
func (m *ACLContentValue) Reset() { *m = ACLContentValue{} }
|
||||
@ -366,35 +365,35 @@ func (m *ACLContentValue) XXX_DiscardUnknown() {
|
||||
|
||||
var xxx_messageInfo_ACLContentValue proto.InternalMessageInfo
|
||||
|
||||
type isACLContentValue_Value interface {
|
||||
isACLContentValue_Value()
|
||||
type IsACLContentValueValue interface {
|
||||
IsACLContentValueValue()
|
||||
MarshalTo([]byte) (int, error)
|
||||
Size() int
|
||||
}
|
||||
|
||||
type ACLContentValue_UserAdd struct {
|
||||
type ACLContentValueValueOfUserAdd struct {
|
||||
UserAdd *ACLUserAdd `protobuf:"bytes,1,opt,name=userAdd,proto3,oneof" json:"userAdd,omitempty"`
|
||||
}
|
||||
type ACLContentValue_UserRemove struct {
|
||||
type ACLContentValueValueOfUserRemove struct {
|
||||
UserRemove *ACLUserRemove `protobuf:"bytes,2,opt,name=userRemove,proto3,oneof" json:"userRemove,omitempty"`
|
||||
}
|
||||
type ACLContentValue_UserPermissionChange struct {
|
||||
type ACLContentValueValueOfUserPermissionChange struct {
|
||||
UserPermissionChange *ACLUserPermissionChange `protobuf:"bytes,3,opt,name=userPermissionChange,proto3,oneof" json:"userPermissionChange,omitempty"`
|
||||
}
|
||||
type ACLContentValue_UserInvite struct {
|
||||
type ACLContentValueValueOfUserInvite struct {
|
||||
UserInvite *ACLUserInvite `protobuf:"bytes,4,opt,name=userInvite,proto3,oneof" json:"userInvite,omitempty"`
|
||||
}
|
||||
type ACLContentValue_UserJoin struct {
|
||||
type ACLContentValueValueOfUserJoin struct {
|
||||
UserJoin *ACLUserJoin `protobuf:"bytes,5,opt,name=userJoin,proto3,oneof" json:"userJoin,omitempty"`
|
||||
}
|
||||
|
||||
func (*ACLContentValue_UserAdd) isACLContentValue_Value() {}
|
||||
func (*ACLContentValue_UserRemove) isACLContentValue_Value() {}
|
||||
func (*ACLContentValue_UserPermissionChange) isACLContentValue_Value() {}
|
||||
func (*ACLContentValue_UserInvite) isACLContentValue_Value() {}
|
||||
func (*ACLContentValue_UserJoin) isACLContentValue_Value() {}
|
||||
func (*ACLContentValueValueOfUserAdd) IsACLContentValueValue() {}
|
||||
func (*ACLContentValueValueOfUserRemove) IsACLContentValueValue() {}
|
||||
func (*ACLContentValueValueOfUserPermissionChange) IsACLContentValueValue() {}
|
||||
func (*ACLContentValueValueOfUserInvite) IsACLContentValueValue() {}
|
||||
func (*ACLContentValueValueOfUserJoin) IsACLContentValueValue() {}
|
||||
|
||||
func (m *ACLContentValue) GetValue() isACLContentValue_Value {
|
||||
func (m *ACLContentValue) GetValue() IsACLContentValueValue {
|
||||
if m != nil {
|
||||
return m.Value
|
||||
}
|
||||
@ -402,35 +401,35 @@ func (m *ACLContentValue) GetValue() isACLContentValue_Value {
|
||||
}
|
||||
|
||||
func (m *ACLContentValue) GetUserAdd() *ACLUserAdd {
|
||||
if x, ok := m.GetValue().(*ACLContentValue_UserAdd); ok {
|
||||
if x, ok := m.GetValue().(*ACLContentValueValueOfUserAdd); ok {
|
||||
return x.UserAdd
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *ACLContentValue) GetUserRemove() *ACLUserRemove {
|
||||
if x, ok := m.GetValue().(*ACLContentValue_UserRemove); ok {
|
||||
if x, ok := m.GetValue().(*ACLContentValueValueOfUserRemove); ok {
|
||||
return x.UserRemove
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *ACLContentValue) GetUserPermissionChange() *ACLUserPermissionChange {
|
||||
if x, ok := m.GetValue().(*ACLContentValue_UserPermissionChange); ok {
|
||||
if x, ok := m.GetValue().(*ACLContentValueValueOfUserPermissionChange); ok {
|
||||
return x.UserPermissionChange
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *ACLContentValue) GetUserInvite() *ACLUserInvite {
|
||||
if x, ok := m.GetValue().(*ACLContentValue_UserInvite); ok {
|
||||
if x, ok := m.GetValue().(*ACLContentValueValueOfUserInvite); ok {
|
||||
return x.UserInvite
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *ACLContentValue) GetUserJoin() *ACLUserJoin {
|
||||
if x, ok := m.GetValue().(*ACLContentValue_UserJoin); ok {
|
||||
if x, ok := m.GetValue().(*ACLContentValueValueOfUserJoin); ok {
|
||||
return x.UserJoin
|
||||
}
|
||||
return nil
|
||||
@ -439,11 +438,11 @@ func (m *ACLContentValue) GetUserJoin() *ACLUserJoin {
|
||||
// XXX_OneofWrappers is for the internal use of the proto package.
|
||||
func (*ACLContentValue) XXX_OneofWrappers() []interface{} {
|
||||
return []interface{}{
|
||||
(*ACLContentValue_UserAdd)(nil),
|
||||
(*ACLContentValue_UserRemove)(nil),
|
||||
(*ACLContentValue_UserPermissionChange)(nil),
|
||||
(*ACLContentValue_UserInvite)(nil),
|
||||
(*ACLContentValue_UserJoin)(nil),
|
||||
(*ACLContentValueValueOfUserAdd)(nil),
|
||||
(*ACLContentValueValueOfUserRemove)(nil),
|
||||
(*ACLContentValueValueOfUserPermissionChange)(nil),
|
||||
(*ACLContentValueValueOfUserInvite)(nil),
|
||||
(*ACLContentValueValueOfUserJoin)(nil),
|
||||
}
|
||||
}
|
||||
|
||||
@ -1304,12 +1303,12 @@ func (m *ACLContentValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||||
return len(dAtA) - i, nil
|
||||
}
|
||||
|
||||
func (m *ACLContentValue_UserAdd) MarshalTo(dAtA []byte) (int, error) {
|
||||
func (m *ACLContentValueValueOfUserAdd) MarshalTo(dAtA []byte) (int, error) {
|
||||
size := m.Size()
|
||||
return m.MarshalToSizedBuffer(dAtA[:size])
|
||||
}
|
||||
|
||||
func (m *ACLContentValue_UserAdd) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||||
func (m *ACLContentValueValueOfUserAdd) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||||
i := len(dAtA)
|
||||
if m.UserAdd != nil {
|
||||
{
|
||||
@ -1325,12 +1324,12 @@ func (m *ACLContentValue_UserAdd) MarshalToSizedBuffer(dAtA []byte) (int, error)
|
||||
}
|
||||
return len(dAtA) - i, nil
|
||||
}
|
||||
func (m *ACLContentValue_UserRemove) MarshalTo(dAtA []byte) (int, error) {
|
||||
func (m *ACLContentValueValueOfUserRemove) MarshalTo(dAtA []byte) (int, error) {
|
||||
size := m.Size()
|
||||
return m.MarshalToSizedBuffer(dAtA[:size])
|
||||
}
|
||||
|
||||
func (m *ACLContentValue_UserRemove) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||||
func (m *ACLContentValueValueOfUserRemove) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||||
i := len(dAtA)
|
||||
if m.UserRemove != nil {
|
||||
{
|
||||
@ -1346,12 +1345,12 @@ func (m *ACLContentValue_UserRemove) MarshalToSizedBuffer(dAtA []byte) (int, err
|
||||
}
|
||||
return len(dAtA) - i, nil
|
||||
}
|
||||
func (m *ACLContentValue_UserPermissionChange) MarshalTo(dAtA []byte) (int, error) {
|
||||
func (m *ACLContentValueValueOfUserPermissionChange) MarshalTo(dAtA []byte) (int, error) {
|
||||
size := m.Size()
|
||||
return m.MarshalToSizedBuffer(dAtA[:size])
|
||||
}
|
||||
|
||||
func (m *ACLContentValue_UserPermissionChange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||||
func (m *ACLContentValueValueOfUserPermissionChange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||||
i := len(dAtA)
|
||||
if m.UserPermissionChange != nil {
|
||||
{
|
||||
@ -1367,12 +1366,12 @@ func (m *ACLContentValue_UserPermissionChange) MarshalToSizedBuffer(dAtA []byte)
|
||||
}
|
||||
return len(dAtA) - i, nil
|
||||
}
|
||||
func (m *ACLContentValue_UserInvite) MarshalTo(dAtA []byte) (int, error) {
|
||||
func (m *ACLContentValueValueOfUserInvite) MarshalTo(dAtA []byte) (int, error) {
|
||||
size := m.Size()
|
||||
return m.MarshalToSizedBuffer(dAtA[:size])
|
||||
}
|
||||
|
||||
func (m *ACLContentValue_UserInvite) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||||
func (m *ACLContentValueValueOfUserInvite) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||||
i := len(dAtA)
|
||||
if m.UserInvite != nil {
|
||||
{
|
||||
@ -1388,12 +1387,12 @@ func (m *ACLContentValue_UserInvite) MarshalToSizedBuffer(dAtA []byte) (int, err
|
||||
}
|
||||
return len(dAtA) - i, nil
|
||||
}
|
||||
func (m *ACLContentValue_UserJoin) MarshalTo(dAtA []byte) (int, error) {
|
||||
func (m *ACLContentValueValueOfUserJoin) MarshalTo(dAtA []byte) (int, error) {
|
||||
size := m.Size()
|
||||
return m.MarshalToSizedBuffer(dAtA[:size])
|
||||
}
|
||||
|
||||
func (m *ACLContentValue_UserJoin) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||||
func (m *ACLContentValueValueOfUserJoin) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||||
i := len(dAtA)
|
||||
if m.UserJoin != nil {
|
||||
{
|
||||
@ -1980,7 +1979,7 @@ func (m *ACLContentValue) Size() (n int) {
|
||||
return n
|
||||
}
|
||||
|
||||
func (m *ACLContentValue_UserAdd) Size() (n int) {
|
||||
func (m *ACLContentValueValueOfUserAdd) Size() (n int) {
|
||||
if m == nil {
|
||||
return 0
|
||||
}
|
||||
@ -1992,7 +1991,7 @@ func (m *ACLContentValue_UserAdd) Size() (n int) {
|
||||
}
|
||||
return n
|
||||
}
|
||||
func (m *ACLContentValue_UserRemove) Size() (n int) {
|
||||
func (m *ACLContentValueValueOfUserRemove) Size() (n int) {
|
||||
if m == nil {
|
||||
return 0
|
||||
}
|
||||
@ -2004,7 +2003,7 @@ func (m *ACLContentValue_UserRemove) Size() (n int) {
|
||||
}
|
||||
return n
|
||||
}
|
||||
func (m *ACLContentValue_UserPermissionChange) Size() (n int) {
|
||||
func (m *ACLContentValueValueOfUserPermissionChange) Size() (n int) {
|
||||
if m == nil {
|
||||
return 0
|
||||
}
|
||||
@ -2016,7 +2015,7 @@ func (m *ACLContentValue_UserPermissionChange) Size() (n int) {
|
||||
}
|
||||
return n
|
||||
}
|
||||
func (m *ACLContentValue_UserInvite) Size() (n int) {
|
||||
func (m *ACLContentValueValueOfUserInvite) Size() (n int) {
|
||||
if m == nil {
|
||||
return 0
|
||||
}
|
||||
@ -2028,7 +2027,7 @@ func (m *ACLContentValue_UserInvite) Size() (n int) {
|
||||
}
|
||||
return n
|
||||
}
|
||||
func (m *ACLContentValue_UserJoin) Size() (n int) {
|
||||
func (m *ACLContentValueValueOfUserJoin) Size() (n int) {
|
||||
if m == nil {
|
||||
return 0
|
||||
}
|
||||
@ -2997,7 +2996,7 @@ func (m *ACLContentValue) Unmarshal(dAtA []byte) error {
|
||||
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
||||
return err
|
||||
}
|
||||
m.Value = &ACLContentValue_UserAdd{v}
|
||||
m.Value = &ACLContentValueValueOfUserAdd{v}
|
||||
iNdEx = postIndex
|
||||
case 2:
|
||||
if wireType != 2 {
|
||||
@ -3032,7 +3031,7 @@ func (m *ACLContentValue) Unmarshal(dAtA []byte) error {
|
||||
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
||||
return err
|
||||
}
|
||||
m.Value = &ACLContentValue_UserRemove{v}
|
||||
m.Value = &ACLContentValueValueOfUserRemove{v}
|
||||
iNdEx = postIndex
|
||||
case 3:
|
||||
if wireType != 2 {
|
||||
@ -3067,7 +3066,7 @@ func (m *ACLContentValue) Unmarshal(dAtA []byte) error {
|
||||
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
||||
return err
|
||||
}
|
||||
m.Value = &ACLContentValue_UserPermissionChange{v}
|
||||
m.Value = &ACLContentValueValueOfUserPermissionChange{v}
|
||||
iNdEx = postIndex
|
||||
case 4:
|
||||
if wireType != 2 {
|
||||
@ -3102,7 +3101,7 @@ func (m *ACLContentValue) Unmarshal(dAtA []byte) error {
|
||||
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
||||
return err
|
||||
}
|
||||
m.Value = &ACLContentValue_UserInvite{v}
|
||||
m.Value = &ACLContentValueValueOfUserInvite{v}
|
||||
iNdEx = postIndex
|
||||
case 5:
|
||||
if wireType != 2 {
|
||||
@ -3137,7 +3136,7 @@ func (m *ACLContentValue) Unmarshal(dAtA []byte) error {
|
||||
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
||||
return err
|
||||
}
|
||||
m.Value = &ACLContentValue_UserJoin{v}
|
||||
m.Value = &ACLContentValueValueOfUserJoin{v}
|
||||
iNdEx = postIndex
|
||||
default:
|
||||
iNdEx = preIndex
|
||||
|
||||
@ -22,21 +22,24 @@ var _ = math.Inf
|
||||
// proto package needs to be updated.
|
||||
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
|
||||
|
||||
type PlainTextChange struct {
|
||||
type TextContent struct {
|
||||
// Types that are valid to be assigned to Value:
|
||||
// *TextContentValueOfTextAppend
|
||||
Value IsTextContentValue `protobuf_oneof:"value"`
|
||||
}
|
||||
|
||||
func (m *PlainTextChange) Reset() { *m = PlainTextChange{} }
|
||||
func (m *PlainTextChange) String() string { return proto.CompactTextString(m) }
|
||||
func (*PlainTextChange) ProtoMessage() {}
|
||||
func (*PlainTextChange) Descriptor() ([]byte, []int) {
|
||||
func (m *TextContent) Reset() { *m = TextContent{} }
|
||||
func (m *TextContent) String() string { return proto.CompactTextString(m) }
|
||||
func (*TextContent) ProtoMessage() {}
|
||||
func (*TextContent) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_37f33c266ada4318, []int{0}
|
||||
}
|
||||
func (m *PlainTextChange) XXX_Unmarshal(b []byte) error {
|
||||
func (m *TextContent) XXX_Unmarshal(b []byte) error {
|
||||
return m.Unmarshal(b)
|
||||
}
|
||||
func (m *PlainTextChange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||||
func (m *TextContent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||||
if deterministic {
|
||||
return xxx_messageInfo_PlainTextChange.Marshal(b, m, deterministic)
|
||||
return xxx_messageInfo_TextContent.Marshal(b, m, deterministic)
|
||||
} else {
|
||||
b = b[:cap(b)]
|
||||
n, err := m.MarshalToSizedBuffer(b)
|
||||
@ -46,107 +49,67 @@ func (m *PlainTextChange) XXX_Marshal(b []byte, deterministic bool) ([]byte, err
|
||||
return b[:n], nil
|
||||
}
|
||||
}
|
||||
func (m *PlainTextChange) XXX_Merge(src proto.Message) {
|
||||
xxx_messageInfo_PlainTextChange.Merge(m, src)
|
||||
func (m *TextContent) XXX_Merge(src proto.Message) {
|
||||
xxx_messageInfo_TextContent.Merge(m, src)
|
||||
}
|
||||
func (m *PlainTextChange) XXX_Size() int {
|
||||
func (m *TextContent) XXX_Size() int {
|
||||
return m.Size()
|
||||
}
|
||||
func (m *PlainTextChange) XXX_DiscardUnknown() {
|
||||
xxx_messageInfo_PlainTextChange.DiscardUnknown(m)
|
||||
func (m *TextContent) XXX_DiscardUnknown() {
|
||||
xxx_messageInfo_TextContent.DiscardUnknown(m)
|
||||
}
|
||||
|
||||
var xxx_messageInfo_PlainTextChange proto.InternalMessageInfo
|
||||
var xxx_messageInfo_TextContent proto.InternalMessageInfo
|
||||
|
||||
type PlainTextChange_Content struct {
|
||||
// Types that are valid to be assigned to Value:
|
||||
//
|
||||
// *PlainTextChange_Content_TextAppend
|
||||
Value isPlainTextChange_Content_Value `protobuf_oneof:"value"`
|
||||
}
|
||||
|
||||
func (m *PlainTextChange_Content) Reset() { *m = PlainTextChange_Content{} }
|
||||
func (m *PlainTextChange_Content) String() string { return proto.CompactTextString(m) }
|
||||
func (*PlainTextChange_Content) ProtoMessage() {}
|
||||
func (*PlainTextChange_Content) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_37f33c266ada4318, []int{0, 0}
|
||||
}
|
||||
func (m *PlainTextChange_Content) XXX_Unmarshal(b []byte) error {
|
||||
return m.Unmarshal(b)
|
||||
}
|
||||
func (m *PlainTextChange_Content) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||||
if deterministic {
|
||||
return xxx_messageInfo_PlainTextChange_Content.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 *PlainTextChange_Content) XXX_Merge(src proto.Message) {
|
||||
xxx_messageInfo_PlainTextChange_Content.Merge(m, src)
|
||||
}
|
||||
func (m *PlainTextChange_Content) XXX_Size() int {
|
||||
return m.Size()
|
||||
}
|
||||
func (m *PlainTextChange_Content) XXX_DiscardUnknown() {
|
||||
xxx_messageInfo_PlainTextChange_Content.DiscardUnknown(m)
|
||||
}
|
||||
|
||||
var xxx_messageInfo_PlainTextChange_Content proto.InternalMessageInfo
|
||||
|
||||
type isPlainTextChange_Content_Value interface {
|
||||
isPlainTextChange_Content_Value()
|
||||
type IsTextContentValue interface {
|
||||
IsTextContentValue()
|
||||
MarshalTo([]byte) (int, error)
|
||||
Size() int
|
||||
}
|
||||
|
||||
type PlainTextChange_Content_TextAppend struct {
|
||||
TextAppend *PlainTextChange_TextAppend `protobuf:"bytes,1,opt,name=textAppend,proto3,oneof" json:"textAppend,omitempty"`
|
||||
type TextContentValueOfTextAppend struct {
|
||||
TextAppend *TextAppend `protobuf:"bytes,1,opt,name=textAppend,proto3,oneof" json:"textAppend,omitempty"`
|
||||
}
|
||||
|
||||
func (*PlainTextChange_Content_TextAppend) isPlainTextChange_Content_Value() {}
|
||||
func (*TextContentValueOfTextAppend) IsTextContentValue() {}
|
||||
|
||||
func (m *PlainTextChange_Content) GetValue() isPlainTextChange_Content_Value {
|
||||
func (m *TextContent) GetValue() IsTextContentValue {
|
||||
if m != nil {
|
||||
return m.Value
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *PlainTextChange_Content) GetTextAppend() *PlainTextChange_TextAppend {
|
||||
if x, ok := m.GetValue().(*PlainTextChange_Content_TextAppend); ok {
|
||||
func (m *TextContent) GetTextAppend() *TextAppend {
|
||||
if x, ok := m.GetValue().(*TextContentValueOfTextAppend); ok {
|
||||
return x.TextAppend
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// XXX_OneofWrappers is for the internal use of the proto package.
|
||||
func (*PlainTextChange_Content) XXX_OneofWrappers() []interface{} {
|
||||
func (*TextContent) XXX_OneofWrappers() []interface{} {
|
||||
return []interface{}{
|
||||
(*PlainTextChange_Content_TextAppend)(nil),
|
||||
(*TextContentValueOfTextAppend)(nil),
|
||||
}
|
||||
}
|
||||
|
||||
type PlainTextChange_TextAppend struct {
|
||||
type TextAppend struct {
|
||||
Text string `protobuf:"bytes,1,opt,name=text,proto3" json:"text,omitempty"`
|
||||
}
|
||||
|
||||
func (m *PlainTextChange_TextAppend) Reset() { *m = PlainTextChange_TextAppend{} }
|
||||
func (m *PlainTextChange_TextAppend) String() string { return proto.CompactTextString(m) }
|
||||
func (*PlainTextChange_TextAppend) ProtoMessage() {}
|
||||
func (*PlainTextChange_TextAppend) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_37f33c266ada4318, []int{0, 1}
|
||||
func (m *TextAppend) Reset() { *m = TextAppend{} }
|
||||
func (m *TextAppend) String() string { return proto.CompactTextString(m) }
|
||||
func (*TextAppend) ProtoMessage() {}
|
||||
func (*TextAppend) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_37f33c266ada4318, []int{1}
|
||||
}
|
||||
func (m *PlainTextChange_TextAppend) XXX_Unmarshal(b []byte) error {
|
||||
func (m *TextAppend) XXX_Unmarshal(b []byte) error {
|
||||
return m.Unmarshal(b)
|
||||
}
|
||||
func (m *PlainTextChange_TextAppend) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||||
func (m *TextAppend) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||||
if deterministic {
|
||||
return xxx_messageInfo_PlainTextChange_TextAppend.Marshal(b, m, deterministic)
|
||||
return xxx_messageInfo_TextAppend.Marshal(b, m, deterministic)
|
||||
} else {
|
||||
b = b[:cap(b)]
|
||||
n, err := m.MarshalToSizedBuffer(b)
|
||||
@ -156,41 +119,41 @@ func (m *PlainTextChange_TextAppend) XXX_Marshal(b []byte, deterministic bool) (
|
||||
return b[:n], nil
|
||||
}
|
||||
}
|
||||
func (m *PlainTextChange_TextAppend) XXX_Merge(src proto.Message) {
|
||||
xxx_messageInfo_PlainTextChange_TextAppend.Merge(m, src)
|
||||
func (m *TextAppend) XXX_Merge(src proto.Message) {
|
||||
xxx_messageInfo_TextAppend.Merge(m, src)
|
||||
}
|
||||
func (m *PlainTextChange_TextAppend) XXX_Size() int {
|
||||
func (m *TextAppend) XXX_Size() int {
|
||||
return m.Size()
|
||||
}
|
||||
func (m *PlainTextChange_TextAppend) XXX_DiscardUnknown() {
|
||||
xxx_messageInfo_PlainTextChange_TextAppend.DiscardUnknown(m)
|
||||
func (m *TextAppend) XXX_DiscardUnknown() {
|
||||
xxx_messageInfo_TextAppend.DiscardUnknown(m)
|
||||
}
|
||||
|
||||
var xxx_messageInfo_PlainTextChange_TextAppend proto.InternalMessageInfo
|
||||
var xxx_messageInfo_TextAppend proto.InternalMessageInfo
|
||||
|
||||
func (m *PlainTextChange_TextAppend) GetText() string {
|
||||
func (m *TextAppend) GetText() string {
|
||||
if m != nil {
|
||||
return m.Text
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
type PlainTextChange_Snapshot struct {
|
||||
type TextSnapshot struct {
|
||||
Text string `protobuf:"bytes,1,opt,name=text,proto3" json:"text,omitempty"`
|
||||
}
|
||||
|
||||
func (m *PlainTextChange_Snapshot) Reset() { *m = PlainTextChange_Snapshot{} }
|
||||
func (m *PlainTextChange_Snapshot) String() string { return proto.CompactTextString(m) }
|
||||
func (*PlainTextChange_Snapshot) ProtoMessage() {}
|
||||
func (*PlainTextChange_Snapshot) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_37f33c266ada4318, []int{0, 2}
|
||||
func (m *TextSnapshot) Reset() { *m = TextSnapshot{} }
|
||||
func (m *TextSnapshot) String() string { return proto.CompactTextString(m) }
|
||||
func (*TextSnapshot) ProtoMessage() {}
|
||||
func (*TextSnapshot) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_37f33c266ada4318, []int{2}
|
||||
}
|
||||
func (m *PlainTextChange_Snapshot) XXX_Unmarshal(b []byte) error {
|
||||
func (m *TextSnapshot) XXX_Unmarshal(b []byte) error {
|
||||
return m.Unmarshal(b)
|
||||
}
|
||||
func (m *PlainTextChange_Snapshot) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||||
func (m *TextSnapshot) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||||
if deterministic {
|
||||
return xxx_messageInfo_PlainTextChange_Snapshot.Marshal(b, m, deterministic)
|
||||
return xxx_messageInfo_TextSnapshot.Marshal(b, m, deterministic)
|
||||
} else {
|
||||
b = b[:cap(b)]
|
||||
n, err := m.MarshalToSizedBuffer(b)
|
||||
@ -200,42 +163,42 @@ func (m *PlainTextChange_Snapshot) XXX_Marshal(b []byte, deterministic bool) ([]
|
||||
return b[:n], nil
|
||||
}
|
||||
}
|
||||
func (m *PlainTextChange_Snapshot) XXX_Merge(src proto.Message) {
|
||||
xxx_messageInfo_PlainTextChange_Snapshot.Merge(m, src)
|
||||
func (m *TextSnapshot) XXX_Merge(src proto.Message) {
|
||||
xxx_messageInfo_TextSnapshot.Merge(m, src)
|
||||
}
|
||||
func (m *PlainTextChange_Snapshot) XXX_Size() int {
|
||||
func (m *TextSnapshot) XXX_Size() int {
|
||||
return m.Size()
|
||||
}
|
||||
func (m *PlainTextChange_Snapshot) XXX_DiscardUnknown() {
|
||||
xxx_messageInfo_PlainTextChange_Snapshot.DiscardUnknown(m)
|
||||
func (m *TextSnapshot) XXX_DiscardUnknown() {
|
||||
xxx_messageInfo_TextSnapshot.DiscardUnknown(m)
|
||||
}
|
||||
|
||||
var xxx_messageInfo_PlainTextChange_Snapshot proto.InternalMessageInfo
|
||||
var xxx_messageInfo_TextSnapshot proto.InternalMessageInfo
|
||||
|
||||
func (m *PlainTextChange_Snapshot) GetText() string {
|
||||
func (m *TextSnapshot) GetText() string {
|
||||
if m != nil {
|
||||
return m.Text
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
type PlainTextChange_Data struct {
|
||||
Content []*PlainTextChange_Content `protobuf:"bytes,1,rep,name=content,proto3" json:"content,omitempty"`
|
||||
Snapshot *PlainTextChange_Snapshot `protobuf:"bytes,2,opt,name=snapshot,proto3" json:"snapshot,omitempty"`
|
||||
type TextData struct {
|
||||
Content []*TextContent `protobuf:"bytes,1,rep,name=content,proto3" json:"content,omitempty"`
|
||||
Snapshot *TextSnapshot `protobuf:"bytes,2,opt,name=snapshot,proto3" json:"snapshot,omitempty"`
|
||||
}
|
||||
|
||||
func (m *PlainTextChange_Data) Reset() { *m = PlainTextChange_Data{} }
|
||||
func (m *PlainTextChange_Data) String() string { return proto.CompactTextString(m) }
|
||||
func (*PlainTextChange_Data) ProtoMessage() {}
|
||||
func (*PlainTextChange_Data) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_37f33c266ada4318, []int{0, 3}
|
||||
func (m *TextData) Reset() { *m = TextData{} }
|
||||
func (m *TextData) String() string { return proto.CompactTextString(m) }
|
||||
func (*TextData) ProtoMessage() {}
|
||||
func (*TextData) Descriptor() ([]byte, []int) {
|
||||
return fileDescriptor_37f33c266ada4318, []int{3}
|
||||
}
|
||||
func (m *PlainTextChange_Data) XXX_Unmarshal(b []byte) error {
|
||||
func (m *TextData) XXX_Unmarshal(b []byte) error {
|
||||
return m.Unmarshal(b)
|
||||
}
|
||||
func (m *PlainTextChange_Data) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||||
func (m *TextData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
|
||||
if deterministic {
|
||||
return xxx_messageInfo_PlainTextChange_Data.Marshal(b, m, deterministic)
|
||||
return xxx_messageInfo_TextData.Marshal(b, m, deterministic)
|
||||
} else {
|
||||
b = b[:cap(b)]
|
||||
n, err := m.MarshalToSizedBuffer(b)
|
||||
@ -245,26 +208,26 @@ func (m *PlainTextChange_Data) XXX_Marshal(b []byte, deterministic bool) ([]byte
|
||||
return b[:n], nil
|
||||
}
|
||||
}
|
||||
func (m *PlainTextChange_Data) XXX_Merge(src proto.Message) {
|
||||
xxx_messageInfo_PlainTextChange_Data.Merge(m, src)
|
||||
func (m *TextData) XXX_Merge(src proto.Message) {
|
||||
xxx_messageInfo_TextData.Merge(m, src)
|
||||
}
|
||||
func (m *PlainTextChange_Data) XXX_Size() int {
|
||||
func (m *TextData) XXX_Size() int {
|
||||
return m.Size()
|
||||
}
|
||||
func (m *PlainTextChange_Data) XXX_DiscardUnknown() {
|
||||
xxx_messageInfo_PlainTextChange_Data.DiscardUnknown(m)
|
||||
func (m *TextData) XXX_DiscardUnknown() {
|
||||
xxx_messageInfo_TextData.DiscardUnknown(m)
|
||||
}
|
||||
|
||||
var xxx_messageInfo_PlainTextChange_Data proto.InternalMessageInfo
|
||||
var xxx_messageInfo_TextData proto.InternalMessageInfo
|
||||
|
||||
func (m *PlainTextChange_Data) GetContent() []*PlainTextChange_Content {
|
||||
func (m *TextData) GetContent() []*TextContent {
|
||||
if m != nil {
|
||||
return m.Content
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (m *PlainTextChange_Data) GetSnapshot() *PlainTextChange_Snapshot {
|
||||
func (m *TextData) GetSnapshot() *TextSnapshot {
|
||||
if m != nil {
|
||||
return m.Snapshot
|
||||
}
|
||||
@ -272,11 +235,10 @@ func (m *PlainTextChange_Data) GetSnapshot() *PlainTextChange_Snapshot {
|
||||
}
|
||||
|
||||
func init() {
|
||||
proto.RegisterType((*PlainTextChange)(nil), "anytype.PlainTextChange")
|
||||
proto.RegisterType((*PlainTextChange_Content)(nil), "anytype.PlainTextChange.Content")
|
||||
proto.RegisterType((*PlainTextChange_TextAppend)(nil), "anytype.PlainTextChange.TextAppend")
|
||||
proto.RegisterType((*PlainTextChange_Snapshot)(nil), "anytype.PlainTextChange.Snapshot")
|
||||
proto.RegisterType((*PlainTextChange_Data)(nil), "anytype.PlainTextChange.Data")
|
||||
proto.RegisterType((*TextContent)(nil), "anytype.TextContent")
|
||||
proto.RegisterType((*TextAppend)(nil), "anytype.TextAppend")
|
||||
proto.RegisterType((*TextSnapshot)(nil), "anytype.TextSnapshot")
|
||||
proto.RegisterType((*TextData)(nil), "anytype.TextData")
|
||||
}
|
||||
|
||||
func init() {
|
||||
@ -284,27 +246,26 @@ func init() {
|
||||
}
|
||||
|
||||
var fileDescriptor_37f33c266ada4318 = []byte{
|
||||
// 266 bytes of a gzipped FileDescriptorProto
|
||||
// 252 bytes of a gzipped FileDescriptorProto
|
||||
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xd2, 0x2b, 0xc8, 0x4e, 0xd7,
|
||||
0x4f, 0x4c, 0xce, 0xd1, 0x2f, 0x49, 0x2d, 0x2e, 0x29, 0x2d, 0xc9, 0xcc, 0x29, 0x06, 0xb3, 0x92,
|
||||
0x33, 0x12, 0xf3, 0xd2, 0x53, 0x8b, 0xf5, 0x0b, 0x8a, 0xf2, 0x4b, 0xf2, 0xc1, 0x22, 0x7a, 0x60,
|
||||
0xa6, 0x10, 0x7b, 0x62, 0x5e, 0x65, 0x49, 0x65, 0x41, 0xaa, 0xd2, 0x26, 0x26, 0x2e, 0xfe, 0x80,
|
||||
0x9c, 0xc4, 0xcc, 0xbc, 0x90, 0xd4, 0x8a, 0x12, 0x67, 0xb0, 0x72, 0xa9, 0x48, 0x2e, 0x76, 0xe7,
|
||||
0xfc, 0xbc, 0x92, 0xd4, 0xbc, 0x12, 0x21, 0x57, 0x2e, 0xae, 0x92, 0xd4, 0x8a, 0x12, 0xc7, 0x82,
|
||||
0x82, 0xd4, 0xbc, 0x14, 0x09, 0x46, 0x05, 0x46, 0x0d, 0x6e, 0x23, 0x65, 0x3d, 0xa8, 0x66, 0x3d,
|
||||
0x34, 0x8d, 0x7a, 0x21, 0x70, 0xa5, 0x1e, 0x0c, 0x41, 0x48, 0x1a, 0x9d, 0xd8, 0xb9, 0x58, 0xcb,
|
||||
0x12, 0x73, 0x4a, 0x53, 0xa5, 0x14, 0xb8, 0xb8, 0x10, 0x8a, 0x84, 0x84, 0xb8, 0x58, 0x40, 0x8a,
|
||||
0xc0, 0xe6, 0x72, 0x06, 0x81, 0xd9, 0x52, 0x72, 0x5c, 0x1c, 0xc1, 0x79, 0x89, 0x05, 0xc5, 0x19,
|
||||
0xf9, 0x25, 0x58, 0xe5, 0x1b, 0x19, 0xb9, 0x58, 0x5c, 0x12, 0x4b, 0x12, 0x85, 0xac, 0xb8, 0xd8,
|
||||
0x93, 0x21, 0xae, 0x94, 0x60, 0x54, 0x60, 0xd6, 0xe0, 0x36, 0x52, 0xc0, 0xe9, 0x2e, 0xa8, 0x6f,
|
||||
0x82, 0x60, 0x1a, 0x84, 0x6c, 0xb9, 0x38, 0x8a, 0xa1, 0x96, 0x48, 0x30, 0x81, 0x3d, 0xa5, 0x88,
|
||||
0x53, 0x33, 0xcc, 0x35, 0x41, 0x70, 0x2d, 0x4e, 0xaa, 0x27, 0x1e, 0xc9, 0x31, 0x5e, 0x78, 0x24,
|
||||
0xc7, 0xf8, 0xe0, 0x91, 0x1c, 0xe3, 0x84, 0xc7, 0x72, 0x0c, 0x17, 0x1e, 0xcb, 0x31, 0xdc, 0x78,
|
||||
0x2c, 0xc7, 0x10, 0xc5, 0x8d, 0x14, 0xea, 0x49, 0x6c, 0xe0, 0xb0, 0x36, 0x06, 0x04, 0x00, 0x00,
|
||||
0xff, 0xff, 0xf8, 0x8c, 0x6a, 0x1d, 0x9d, 0x01, 0x00, 0x00,
|
||||
0xa6, 0x10, 0x7b, 0x62, 0x5e, 0x65, 0x49, 0x65, 0x41, 0xaa, 0x92, 0x2f, 0x17, 0x77, 0x48, 0x6a,
|
||||
0x45, 0x89, 0x73, 0x7e, 0x5e, 0x49, 0x6a, 0x5e, 0x89, 0x90, 0x29, 0x17, 0x57, 0x49, 0x6a, 0x45,
|
||||
0x89, 0x63, 0x41, 0x41, 0x6a, 0x5e, 0x8a, 0x04, 0xa3, 0x02, 0xa3, 0x06, 0xb7, 0x91, 0xb0, 0x1e,
|
||||
0x54, 0xb1, 0x5e, 0x08, 0x5c, 0xca, 0x83, 0x21, 0x08, 0x49, 0xa1, 0x13, 0x3b, 0x17, 0x6b, 0x59,
|
||||
0x62, 0x4e, 0x69, 0xaa, 0x92, 0x02, 0x17, 0x17, 0x42, 0x91, 0x90, 0x10, 0x17, 0x0b, 0x48, 0x11,
|
||||
0xd8, 0x1c, 0xce, 0x20, 0x30, 0x5b, 0x49, 0x89, 0x8b, 0x07, 0xa4, 0x22, 0x38, 0x2f, 0xb1, 0xa0,
|
||||
0x38, 0x23, 0xbf, 0x04, 0xab, 0x9a, 0x5c, 0x2e, 0x0e, 0x90, 0x1a, 0x97, 0xc4, 0x92, 0x44, 0x21,
|
||||
0x3d, 0x2e, 0xf6, 0x64, 0x88, 0xe3, 0x24, 0x18, 0x15, 0x98, 0x35, 0xb8, 0x8d, 0x44, 0x50, 0x9c,
|
||||
0x03, 0x75, 0x78, 0x10, 0x4c, 0x91, 0x90, 0x21, 0x17, 0x47, 0x31, 0xd4, 0x6c, 0x09, 0x26, 0xb0,
|
||||
0xfb, 0x45, 0x51, 0x34, 0xc0, 0x2c, 0x0e, 0x82, 0x2b, 0x73, 0x52, 0x3d, 0xf1, 0x48, 0x8e, 0xf1,
|
||||
0xc2, 0x23, 0x39, 0xc6, 0x07, 0x8f, 0xe4, 0x18, 0x27, 0x3c, 0x96, 0x63, 0xb8, 0xf0, 0x58, 0x8e,
|
||||
0xe1, 0xc6, 0x63, 0x39, 0x86, 0x28, 0x6e, 0xa4, 0x40, 0x4c, 0x62, 0x03, 0x07, 0x9d, 0x31, 0x20,
|
||||
0x00, 0x00, 0xff, 0xff, 0xdc, 0xbf, 0x78, 0xe5, 0x6c, 0x01, 0x00, 0x00,
|
||||
}
|
||||
|
||||
func (m *PlainTextChange) Marshal() (dAtA []byte, err error) {
|
||||
func (m *TextContent) Marshal() (dAtA []byte, err error) {
|
||||
size := m.Size()
|
||||
dAtA = make([]byte, size)
|
||||
n, err := m.MarshalToSizedBuffer(dAtA[:size])
|
||||
@ -314,35 +275,12 @@ func (m *PlainTextChange) Marshal() (dAtA []byte, err error) {
|
||||
return dAtA[:n], nil
|
||||
}
|
||||
|
||||
func (m *PlainTextChange) MarshalTo(dAtA []byte) (int, error) {
|
||||
func (m *TextContent) MarshalTo(dAtA []byte) (int, error) {
|
||||
size := m.Size()
|
||||
return m.MarshalToSizedBuffer(dAtA[:size])
|
||||
}
|
||||
|
||||
func (m *PlainTextChange) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||||
i := len(dAtA)
|
||||
_ = i
|
||||
var l int
|
||||
_ = l
|
||||
return len(dAtA) - i, nil
|
||||
}
|
||||
|
||||
func (m *PlainTextChange_Content) 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 *PlainTextChange_Content) MarshalTo(dAtA []byte) (int, error) {
|
||||
size := m.Size()
|
||||
return m.MarshalToSizedBuffer(dAtA[:size])
|
||||
}
|
||||
|
||||
func (m *PlainTextChange_Content) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||||
func (m *TextContent) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||||
i := len(dAtA)
|
||||
_ = i
|
||||
var l int
|
||||
@ -359,12 +297,12 @@ func (m *PlainTextChange_Content) MarshalToSizedBuffer(dAtA []byte) (int, error)
|
||||
return len(dAtA) - i, nil
|
||||
}
|
||||
|
||||
func (m *PlainTextChange_Content_TextAppend) MarshalTo(dAtA []byte) (int, error) {
|
||||
func (m *TextContentValueOfTextAppend) MarshalTo(dAtA []byte) (int, error) {
|
||||
size := m.Size()
|
||||
return m.MarshalToSizedBuffer(dAtA[:size])
|
||||
}
|
||||
|
||||
func (m *PlainTextChange_Content_TextAppend) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||||
func (m *TextContentValueOfTextAppend) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||||
i := len(dAtA)
|
||||
if m.TextAppend != nil {
|
||||
{
|
||||
@ -380,7 +318,7 @@ func (m *PlainTextChange_Content_TextAppend) MarshalToSizedBuffer(dAtA []byte) (
|
||||
}
|
||||
return len(dAtA) - i, nil
|
||||
}
|
||||
func (m *PlainTextChange_TextAppend) Marshal() (dAtA []byte, err error) {
|
||||
func (m *TextAppend) Marshal() (dAtA []byte, err error) {
|
||||
size := m.Size()
|
||||
dAtA = make([]byte, size)
|
||||
n, err := m.MarshalToSizedBuffer(dAtA[:size])
|
||||
@ -390,12 +328,12 @@ func (m *PlainTextChange_TextAppend) Marshal() (dAtA []byte, err error) {
|
||||
return dAtA[:n], nil
|
||||
}
|
||||
|
||||
func (m *PlainTextChange_TextAppend) MarshalTo(dAtA []byte) (int, error) {
|
||||
func (m *TextAppend) MarshalTo(dAtA []byte) (int, error) {
|
||||
size := m.Size()
|
||||
return m.MarshalToSizedBuffer(dAtA[:size])
|
||||
}
|
||||
|
||||
func (m *PlainTextChange_TextAppend) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||||
func (m *TextAppend) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||||
i := len(dAtA)
|
||||
_ = i
|
||||
var l int
|
||||
@ -410,7 +348,7 @@ func (m *PlainTextChange_TextAppend) MarshalToSizedBuffer(dAtA []byte) (int, err
|
||||
return len(dAtA) - i, nil
|
||||
}
|
||||
|
||||
func (m *PlainTextChange_Snapshot) Marshal() (dAtA []byte, err error) {
|
||||
func (m *TextSnapshot) Marshal() (dAtA []byte, err error) {
|
||||
size := m.Size()
|
||||
dAtA = make([]byte, size)
|
||||
n, err := m.MarshalToSizedBuffer(dAtA[:size])
|
||||
@ -420,12 +358,12 @@ func (m *PlainTextChange_Snapshot) Marshal() (dAtA []byte, err error) {
|
||||
return dAtA[:n], nil
|
||||
}
|
||||
|
||||
func (m *PlainTextChange_Snapshot) MarshalTo(dAtA []byte) (int, error) {
|
||||
func (m *TextSnapshot) MarshalTo(dAtA []byte) (int, error) {
|
||||
size := m.Size()
|
||||
return m.MarshalToSizedBuffer(dAtA[:size])
|
||||
}
|
||||
|
||||
func (m *PlainTextChange_Snapshot) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||||
func (m *TextSnapshot) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||||
i := len(dAtA)
|
||||
_ = i
|
||||
var l int
|
||||
@ -440,7 +378,7 @@ func (m *PlainTextChange_Snapshot) MarshalToSizedBuffer(dAtA []byte) (int, error
|
||||
return len(dAtA) - i, nil
|
||||
}
|
||||
|
||||
func (m *PlainTextChange_Data) Marshal() (dAtA []byte, err error) {
|
||||
func (m *TextData) Marshal() (dAtA []byte, err error) {
|
||||
size := m.Size()
|
||||
dAtA = make([]byte, size)
|
||||
n, err := m.MarshalToSizedBuffer(dAtA[:size])
|
||||
@ -450,12 +388,12 @@ func (m *PlainTextChange_Data) Marshal() (dAtA []byte, err error) {
|
||||
return dAtA[:n], nil
|
||||
}
|
||||
|
||||
func (m *PlainTextChange_Data) MarshalTo(dAtA []byte) (int, error) {
|
||||
func (m *TextData) MarshalTo(dAtA []byte) (int, error) {
|
||||
size := m.Size()
|
||||
return m.MarshalToSizedBuffer(dAtA[:size])
|
||||
}
|
||||
|
||||
func (m *PlainTextChange_Data) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||||
func (m *TextData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
|
||||
i := len(dAtA)
|
||||
_ = i
|
||||
var l int
|
||||
@ -500,16 +438,7 @@ func encodeVarintTest(dAtA []byte, offset int, v uint64) int {
|
||||
dAtA[offset] = uint8(v)
|
||||
return base
|
||||
}
|
||||
func (m *PlainTextChange) Size() (n int) {
|
||||
if m == nil {
|
||||
return 0
|
||||
}
|
||||
var l int
|
||||
_ = l
|
||||
return n
|
||||
}
|
||||
|
||||
func (m *PlainTextChange_Content) Size() (n int) {
|
||||
func (m *TextContent) Size() (n int) {
|
||||
if m == nil {
|
||||
return 0
|
||||
}
|
||||
@ -521,7 +450,7 @@ func (m *PlainTextChange_Content) Size() (n int) {
|
||||
return n
|
||||
}
|
||||
|
||||
func (m *PlainTextChange_Content_TextAppend) Size() (n int) {
|
||||
func (m *TextContentValueOfTextAppend) Size() (n int) {
|
||||
if m == nil {
|
||||
return 0
|
||||
}
|
||||
@ -533,7 +462,7 @@ func (m *PlainTextChange_Content_TextAppend) Size() (n int) {
|
||||
}
|
||||
return n
|
||||
}
|
||||
func (m *PlainTextChange_TextAppend) Size() (n int) {
|
||||
func (m *TextAppend) Size() (n int) {
|
||||
if m == nil {
|
||||
return 0
|
||||
}
|
||||
@ -546,7 +475,7 @@ func (m *PlainTextChange_TextAppend) Size() (n int) {
|
||||
return n
|
||||
}
|
||||
|
||||
func (m *PlainTextChange_Snapshot) Size() (n int) {
|
||||
func (m *TextSnapshot) Size() (n int) {
|
||||
if m == nil {
|
||||
return 0
|
||||
}
|
||||
@ -559,7 +488,7 @@ func (m *PlainTextChange_Snapshot) Size() (n int) {
|
||||
return n
|
||||
}
|
||||
|
||||
func (m *PlainTextChange_Data) Size() (n int) {
|
||||
func (m *TextData) Size() (n int) {
|
||||
if m == nil {
|
||||
return 0
|
||||
}
|
||||
@ -584,7 +513,7 @@ func sovTest(x uint64) (n int) {
|
||||
func sozTest(x uint64) (n int) {
|
||||
return sovTest(uint64((x << 1) ^ uint64((int64(x) >> 63))))
|
||||
}
|
||||
func (m *PlainTextChange) Unmarshal(dAtA []byte) error {
|
||||
func (m *TextContent) Unmarshal(dAtA []byte) error {
|
||||
l := len(dAtA)
|
||||
iNdEx := 0
|
||||
for iNdEx < l {
|
||||
@ -607,60 +536,10 @@ func (m *PlainTextChange) Unmarshal(dAtA []byte) error {
|
||||
fieldNum := int32(wire >> 3)
|
||||
wireType := int(wire & 0x7)
|
||||
if wireType == 4 {
|
||||
return fmt.Errorf("proto: PlainTextChange: wiretype end group for non-group")
|
||||
return fmt.Errorf("proto: TextContent: wiretype end group for non-group")
|
||||
}
|
||||
if fieldNum <= 0 {
|
||||
return fmt.Errorf("proto: PlainTextChange: illegal tag %d (wire type %d)", fieldNum, wire)
|
||||
}
|
||||
switch fieldNum {
|
||||
default:
|
||||
iNdEx = preIndex
|
||||
skippy, err := skipTest(dAtA[iNdEx:])
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if (skippy < 0) || (iNdEx+skippy) < 0 {
|
||||
return ErrInvalidLengthTest
|
||||
}
|
||||
if (iNdEx + skippy) > l {
|
||||
return io.ErrUnexpectedEOF
|
||||
}
|
||||
iNdEx += skippy
|
||||
}
|
||||
}
|
||||
|
||||
if iNdEx > l {
|
||||
return io.ErrUnexpectedEOF
|
||||
}
|
||||
return nil
|
||||
}
|
||||
func (m *PlainTextChange_Content) 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 ErrIntOverflowTest
|
||||
}
|
||||
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: Content: wiretype end group for non-group")
|
||||
}
|
||||
if fieldNum <= 0 {
|
||||
return fmt.Errorf("proto: Content: illegal tag %d (wire type %d)", fieldNum, wire)
|
||||
return fmt.Errorf("proto: TextContent: illegal tag %d (wire type %d)", fieldNum, wire)
|
||||
}
|
||||
switch fieldNum {
|
||||
case 1:
|
||||
@ -692,11 +571,11 @@ func (m *PlainTextChange_Content) Unmarshal(dAtA []byte) error {
|
||||
if postIndex > l {
|
||||
return io.ErrUnexpectedEOF
|
||||
}
|
||||
v := &PlainTextChange_TextAppend{}
|
||||
v := &TextAppend{}
|
||||
if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
||||
return err
|
||||
}
|
||||
m.Value = &PlainTextChange_Content_TextAppend{v}
|
||||
m.Value = &TextContentValueOfTextAppend{v}
|
||||
iNdEx = postIndex
|
||||
default:
|
||||
iNdEx = preIndex
|
||||
@ -719,7 +598,7 @@ func (m *PlainTextChange_Content) Unmarshal(dAtA []byte) error {
|
||||
}
|
||||
return nil
|
||||
}
|
||||
func (m *PlainTextChange_TextAppend) Unmarshal(dAtA []byte) error {
|
||||
func (m *TextAppend) Unmarshal(dAtA []byte) error {
|
||||
l := len(dAtA)
|
||||
iNdEx := 0
|
||||
for iNdEx < l {
|
||||
@ -801,7 +680,7 @@ func (m *PlainTextChange_TextAppend) Unmarshal(dAtA []byte) error {
|
||||
}
|
||||
return nil
|
||||
}
|
||||
func (m *PlainTextChange_Snapshot) Unmarshal(dAtA []byte) error {
|
||||
func (m *TextSnapshot) Unmarshal(dAtA []byte) error {
|
||||
l := len(dAtA)
|
||||
iNdEx := 0
|
||||
for iNdEx < l {
|
||||
@ -824,10 +703,10 @@ func (m *PlainTextChange_Snapshot) Unmarshal(dAtA []byte) error {
|
||||
fieldNum := int32(wire >> 3)
|
||||
wireType := int(wire & 0x7)
|
||||
if wireType == 4 {
|
||||
return fmt.Errorf("proto: Snapshot: wiretype end group for non-group")
|
||||
return fmt.Errorf("proto: TextSnapshot: wiretype end group for non-group")
|
||||
}
|
||||
if fieldNum <= 0 {
|
||||
return fmt.Errorf("proto: Snapshot: illegal tag %d (wire type %d)", fieldNum, wire)
|
||||
return fmt.Errorf("proto: TextSnapshot: illegal tag %d (wire type %d)", fieldNum, wire)
|
||||
}
|
||||
switch fieldNum {
|
||||
case 1:
|
||||
@ -883,7 +762,7 @@ func (m *PlainTextChange_Snapshot) Unmarshal(dAtA []byte) error {
|
||||
}
|
||||
return nil
|
||||
}
|
||||
func (m *PlainTextChange_Data) Unmarshal(dAtA []byte) error {
|
||||
func (m *TextData) Unmarshal(dAtA []byte) error {
|
||||
l := len(dAtA)
|
||||
iNdEx := 0
|
||||
for iNdEx < l {
|
||||
@ -906,10 +785,10 @@ func (m *PlainTextChange_Data) Unmarshal(dAtA []byte) error {
|
||||
fieldNum := int32(wire >> 3)
|
||||
wireType := int(wire & 0x7)
|
||||
if wireType == 4 {
|
||||
return fmt.Errorf("proto: Data: wiretype end group for non-group")
|
||||
return fmt.Errorf("proto: TextData: wiretype end group for non-group")
|
||||
}
|
||||
if fieldNum <= 0 {
|
||||
return fmt.Errorf("proto: Data: illegal tag %d (wire type %d)", fieldNum, wire)
|
||||
return fmt.Errorf("proto: TextData: illegal tag %d (wire type %d)", fieldNum, wire)
|
||||
}
|
||||
switch fieldNum {
|
||||
case 1:
|
||||
@ -941,7 +820,7 @@ func (m *PlainTextChange_Data) Unmarshal(dAtA []byte) error {
|
||||
if postIndex > l {
|
||||
return io.ErrUnexpectedEOF
|
||||
}
|
||||
m.Content = append(m.Content, &PlainTextChange_Content{})
|
||||
m.Content = append(m.Content, &TextContent{})
|
||||
if err := m.Content[len(m.Content)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
||||
return err
|
||||
}
|
||||
@ -976,7 +855,7 @@ func (m *PlainTextChange_Data) Unmarshal(dAtA []byte) error {
|
||||
return io.ErrUnexpectedEOF
|
||||
}
|
||||
if m.Snapshot == nil {
|
||||
m.Snapshot = &PlainTextChange_Snapshot{}
|
||||
m.Snapshot = &TextSnapshot{}
|
||||
}
|
||||
if err := m.Snapshot.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
|
||||
return err
|
||||
|
||||
@ -2,23 +2,21 @@ syntax = "proto3";
|
||||
package anytype;
|
||||
option go_package = "testchanges";
|
||||
|
||||
message PlainTextChange {
|
||||
message Content {
|
||||
oneof value {
|
||||
TextAppend textAppend = 1;
|
||||
}
|
||||
message TextContent {
|
||||
oneof value {
|
||||
TextAppend textAppend = 1;
|
||||
}
|
||||
}
|
||||
|
||||
message TextAppend {
|
||||
string text = 1;
|
||||
}
|
||||
message TextAppend {
|
||||
string text = 1;
|
||||
}
|
||||
|
||||
message Snapshot {
|
||||
string text = 1;
|
||||
}
|
||||
message TextSnapshot {
|
||||
string text = 1;
|
||||
}
|
||||
|
||||
message Data {
|
||||
repeated Content content = 1;
|
||||
Snapshot snapshot = 2;
|
||||
}
|
||||
}
|
||||
message TextData {
|
||||
repeated TextContent content = 1;
|
||||
TextSnapshot snapshot = 2;
|
||||
}
|
||||
|
||||
@ -1,6 +1,7 @@
|
||||
//go:generate mockgen -destination mock_ldiff/mock_ldiff.go github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/ldiff Diff,Remote
|
||||
// Package ldiff provides a container of elements with fixed id and changeable content.
|
||||
// Diff can calculate the difference with another diff container (you can make it remote) with minimum hops and traffic.
|
||||
//
|
||||
//go:generate mockgen -destination mock_ldiff/mock_ldiff.go github.com/anytypeio/go-anytype-infrastructure-experiments/common/pkg/ldiff Diff,Remote
|
||||
package ldiff
|
||||
|
||||
import (
|
||||
@ -84,6 +85,10 @@ type Diff interface {
|
||||
RemoveId(id string) error
|
||||
// Diff makes diff with remote container
|
||||
Diff(ctx context.Context, dl Remote) (newIds, changedIds, removedIds []string, err error)
|
||||
// Elements retrieves all elements in the Diff
|
||||
Elements() []Element
|
||||
// Ids retrieves ids of all elements in the Diff
|
||||
Ids() []string
|
||||
}
|
||||
|
||||
// Remote interface for using in the Diff
|
||||
@ -134,6 +139,34 @@ func (d *diff) Set(elements ...Element) {
|
||||
}
|
||||
}
|
||||
|
||||
func (d *diff) Ids() (ids []string) {
|
||||
d.mu.RLock()
|
||||
defer d.mu.RUnlock()
|
||||
|
||||
ids = make([]string, 0, d.sl.Len())
|
||||
|
||||
cur := d.sl.Front()
|
||||
for cur != nil {
|
||||
el := cur.Key().(*element).Element
|
||||
ids = append(ids, el.Id)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (d *diff) Elements() (elements []Element) {
|
||||
d.mu.RLock()
|
||||
defer d.mu.RUnlock()
|
||||
|
||||
elements = make([]Element, 0, d.sl.Len())
|
||||
|
||||
cur := d.sl.Front()
|
||||
for cur != nil {
|
||||
el := cur.Key().(*element).Element
|
||||
elements = append(elements, el)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// RemoveId removes element by id
|
||||
func (d *diff) RemoveId(id string) error {
|
||||
d.mu.Lock()
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user