| // Copyright 2015 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| // This file is autogenerated by: |
| // mojo/public/tools/bindings/mojom_bindings_generator.py |
| // For: |
| // mojom/syncbase.mojom |
| // |
| |
| package syncbase |
| |
| import ( |
| "fmt" |
| "mojo/public/go/bindings" |
| "mojo/public/go/system" |
| "sort" |
| ) |
| |
| type Syncbase interface { |
| ServiceGetPermissions() (outErr Error, outPerms Perms, outVersion string, err error) |
| ServiceSetPermissions(inPerms Perms, inVersion string) (outErr Error, err error) |
| AppCreate(inName string, inPerms Perms) (outErr Error, err error) |
| AppDelete(inName string) (outErr Error, err error) |
| AppExists(inName string) (outErr Error, outExists bool, err error) |
| AppGetPermissions(inName string) (outErr Error, outPerms Perms, outVersion string, err error) |
| AppSetPermissions(inName string, inPerms Perms, inVersion string) (outErr Error, err error) |
| DbCreate(inName string, inPerms Perms) (outErr Error, err error) |
| DbDelete(inName string) (outErr Error, err error) |
| DbExists(inName string) (outErr Error, outExists bool, err error) |
| DbExec(inQuery string) (outErr Error, err error) |
| DbBeginBatch(inName string, inBo *BatchOptions) (outErr Error, outBatchDn string, err error) |
| DbCommit(inName string) (outErr Error, err error) |
| DbAbort(inName string) (outErr Error, err error) |
| DbGetPermissions(inName string) (outErr Error, outPerms Perms, outVersion string, err error) |
| DbSetPermissions(inName string, inPerms Perms, inVersion string) (outErr Error, err error) |
| DbGetSyncGroupNames(inName string) (outErr Error, outNames []string, err error) |
| DbCreateSyncGroup(inName string, inSgName string, inSpec SyncGroupSpec, inMyInfo SyncGroupMemberInfo) (outErr Error, err error) |
| DbJoinSyncGroup(inName string, inSgName string, inMyInfo SyncGroupMemberInfo) (outErr Error, err error) |
| DbLeaveSyncGroup(inName string, inSgName string) (outErr Error, err error) |
| DbDestroySyncGroup(inName string, inSgName string) (outErr Error, err error) |
| DbEjectFromSyncGroup(inName string, inSgName string, inMember string) (outErr Error, err error) |
| DbGetSyncGroupSpec(inName string, inSgName string) (outErr Error, outSpec SyncGroupSpec, outVersion string, err error) |
| DbSetSyncGroupSpec(inName string, inSgName string, inSpec SyncGroupSpec, inVersion string) (outErr Error, err error) |
| DbGetSyncGroupMembers(inName string, inSgName string) (outErr Error, outInfos map[string]SyncGroupMemberInfo, err error) |
| TableCreate(inName string, inPerms Perms) (outErr Error, err error) |
| TableDelete(inName string) (outErr Error, err error) |
| TableExists(inName string) (outErr Error, outExists bool, err error) |
| TableDeleteRowRange(inName string, inStart []uint8, inLimit []uint8) (outErr Error, err error) |
| TableScan(inName string, inStart []uint8, inLimit []uint8) (outErr Error, err error) |
| TableGetPermissions(inName string, inKey string) (outErr Error, outPermsArr []PrefixPerms, err error) |
| TableSetPermissions(inName string, inPrefix string, inPerms Perms) (outErr Error, err error) |
| TableDeletePermissions(inName string, inPrefix string) (outErr Error, err error) |
| RowExists(inName string) (outErr Error, outExists bool, err error) |
| RowGet(inName string) (outErr Error, outValue []uint8, err error) |
| RowPut(inName string, inValue []uint8) (outErr Error, err error) |
| RowDelete(inName string) (outErr Error, err error) |
| } |
| |
| var syncbase_Name = "mojo::syncbase::Syncbase" |
| |
| type Syncbase_Request bindings.InterfaceRequest |
| |
| func (r *Syncbase_Request) Name() string { |
| return syncbase_Name |
| } |
| |
| type Syncbase_Pointer bindings.InterfacePointer |
| |
| func (p *Syncbase_Pointer) Name() string { |
| return syncbase_Name |
| } |
| |
| type Syncbase_ServiceFactory struct { |
| Delegate Syncbase_Factory |
| } |
| |
| type Syncbase_Factory interface { |
| Create(request Syncbase_Request) |
| } |
| |
| func (f *Syncbase_ServiceFactory) Name() string { |
| return syncbase_Name |
| } |
| |
| func (f *Syncbase_ServiceFactory) Create(messagePipe system.MessagePipeHandle) { |
| request := Syncbase_Request{bindings.NewMessagePipeHandleOwner(messagePipe)} |
| f.Delegate.Create(request) |
| } |
| |
| // CreateMessagePipeForSyncbase creates a message pipe for use with the |
| // Syncbase interface with a Syncbase_Request on one end and a Syncbase_Pointer on the other. |
| func CreateMessagePipeForSyncbase() (Syncbase_Request, Syncbase_Pointer) { |
| r, p := bindings.CreateMessagePipeForMojoInterface() |
| return Syncbase_Request(r), Syncbase_Pointer(p) |
| } |
| |
| const syncbase_ServiceGetPermissions_Name uint32 = 0 |
| const syncbase_ServiceSetPermissions_Name uint32 = 1 |
| const syncbase_AppCreate_Name uint32 = 2 |
| const syncbase_AppDelete_Name uint32 = 3 |
| const syncbase_AppExists_Name uint32 = 4 |
| const syncbase_AppGetPermissions_Name uint32 = 5 |
| const syncbase_AppSetPermissions_Name uint32 = 6 |
| const syncbase_DbCreate_Name uint32 = 7 |
| const syncbase_DbDelete_Name uint32 = 8 |
| const syncbase_DbExists_Name uint32 = 9 |
| const syncbase_DbExec_Name uint32 = 10 |
| const syncbase_DbBeginBatch_Name uint32 = 11 |
| const syncbase_DbCommit_Name uint32 = 12 |
| const syncbase_DbAbort_Name uint32 = 13 |
| const syncbase_DbGetPermissions_Name uint32 = 14 |
| const syncbase_DbSetPermissions_Name uint32 = 15 |
| const syncbase_DbGetSyncGroupNames_Name uint32 = 16 |
| const syncbase_DbCreateSyncGroup_Name uint32 = 17 |
| const syncbase_DbJoinSyncGroup_Name uint32 = 18 |
| const syncbase_DbLeaveSyncGroup_Name uint32 = 19 |
| const syncbase_DbDestroySyncGroup_Name uint32 = 20 |
| const syncbase_DbEjectFromSyncGroup_Name uint32 = 21 |
| const syncbase_DbGetSyncGroupSpec_Name uint32 = 22 |
| const syncbase_DbSetSyncGroupSpec_Name uint32 = 23 |
| const syncbase_DbGetSyncGroupMembers_Name uint32 = 24 |
| const syncbase_TableCreate_Name uint32 = 25 |
| const syncbase_TableDelete_Name uint32 = 26 |
| const syncbase_TableExists_Name uint32 = 27 |
| const syncbase_TableDeleteRowRange_Name uint32 = 28 |
| const syncbase_TableScan_Name uint32 = 29 |
| const syncbase_TableGetPermissions_Name uint32 = 30 |
| const syncbase_TableSetPermissions_Name uint32 = 31 |
| const syncbase_TableDeletePermissions_Name uint32 = 32 |
| const syncbase_RowExists_Name uint32 = 33 |
| const syncbase_RowGet_Name uint32 = 34 |
| const syncbase_RowPut_Name uint32 = 35 |
| const syncbase_RowDelete_Name uint32 = 36 |
| |
| type Syncbase_Proxy struct { |
| router *bindings.Router |
| ids bindings.Counter |
| } |
| |
| func NewSyncbaseProxy(p Syncbase_Pointer, waiter bindings.AsyncWaiter) *Syncbase_Proxy { |
| return &Syncbase_Proxy{ |
| bindings.NewRouter(p.PassMessagePipe(), waiter), |
| bindings.NewCounter(), |
| } |
| } |
| |
| func (p *Syncbase_Proxy) Close_Proxy() { |
| p.router.Close() |
| } |
| |
| type syncbase_ServiceGetPermissions_Params struct { |
| } |
| |
| func (s *syncbase_ServiceGetPermissions_Params) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(0, 0) |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_ServiceGetPermissions_Params_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{8, 0}, |
| } |
| |
| func (s *syncbase_ServiceGetPermissions_Params) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_ServiceGetPermissions_Params_Versions), func(i int) bool { |
| return syncbase_ServiceGetPermissions_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_ServiceGetPermissions_Params_Versions) { |
| if syncbase_ServiceGetPermissions_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_ServiceGetPermissions_Params_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| type syncbase_ServiceGetPermissions_ResponseParams struct { |
| outErr Error |
| outPerms Perms |
| outVersion string |
| } |
| |
| func (s *syncbase_ServiceGetPermissions_ResponseParams) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(24, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.outErr.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.outPerms.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.outVersion); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_ServiceGetPermissions_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{32, 0}, |
| } |
| |
| func (s *syncbase_ServiceGetPermissions_ResponseParams) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_ServiceGetPermissions_ResponseParams_Versions), func(i int) bool { |
| return syncbase_ServiceGetPermissions_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_ServiceGetPermissions_ResponseParams_Versions) { |
| if syncbase_ServiceGetPermissions_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_ServiceGetPermissions_ResponseParams_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.outErr.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.outPerms.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.outVersion = value0 |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (p *Syncbase_Proxy) ServiceGetPermissions() (outErr Error, outPerms Perms, outVersion string, err error) { |
| payload := &syncbase_ServiceGetPermissions_Params{} |
| header := bindings.MessageHeader{ |
| Type: syncbase_ServiceGetPermissions_Name, |
| Flags: bindings.MessageExpectsResponseFlag, |
| RequestId: p.ids.Count(), |
| } |
| var message *bindings.Message |
| if message, err = bindings.EncodeMessage(header, payload); err != nil { |
| err = fmt.Errorf("can't encode request: %v", err.Error()) |
| p.Close_Proxy() |
| return |
| } |
| readResult := <-p.router.AcceptWithResponse(message) |
| if err = readResult.Error; err != nil { |
| p.Close_Proxy() |
| return |
| } |
| if readResult.Message.Header.Flags != bindings.MessageIsResponseFlag { |
| err = &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", readResult.Message.Header.Flags), |
| } |
| return |
| } |
| if got, want := readResult.Message.Header.Type, syncbase_ServiceGetPermissions_Name; got != want { |
| err = &bindings.ValidationError{bindings.MessageHeaderUnknownMethod, |
| fmt.Sprintf("invalid method in response: expected %v, got %v", want, got), |
| } |
| return |
| } |
| var response syncbase_ServiceGetPermissions_ResponseParams |
| if err = readResult.Message.DecodePayload(&response); err != nil { |
| p.Close_Proxy() |
| return |
| } |
| outErr = response.outErr |
| outPerms = response.outPerms |
| outVersion = response.outVersion |
| return |
| } |
| |
| type syncbase_ServiceSetPermissions_Params struct { |
| inPerms Perms |
| inVersion string |
| } |
| |
| func (s *syncbase_ServiceSetPermissions_Params) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(16, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.inPerms.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.inVersion); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_ServiceSetPermissions_Params_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{24, 0}, |
| } |
| |
| func (s *syncbase_ServiceSetPermissions_Params) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_ServiceSetPermissions_Params_Versions), func(i int) bool { |
| return syncbase_ServiceSetPermissions_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_ServiceSetPermissions_Params_Versions) { |
| if syncbase_ServiceSetPermissions_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_ServiceSetPermissions_Params_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.inPerms.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.inVersion = value0 |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| type syncbase_ServiceSetPermissions_ResponseParams struct { |
| outErr Error |
| } |
| |
| func (s *syncbase_ServiceSetPermissions_ResponseParams) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(8, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.outErr.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_ServiceSetPermissions_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{16, 0}, |
| } |
| |
| func (s *syncbase_ServiceSetPermissions_ResponseParams) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_ServiceSetPermissions_ResponseParams_Versions), func(i int) bool { |
| return syncbase_ServiceSetPermissions_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_ServiceSetPermissions_ResponseParams_Versions) { |
| if syncbase_ServiceSetPermissions_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_ServiceSetPermissions_ResponseParams_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.outErr.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (p *Syncbase_Proxy) ServiceSetPermissions(inPerms Perms, inVersion string) (outErr Error, err error) { |
| payload := &syncbase_ServiceSetPermissions_Params{ |
| inPerms, |
| inVersion, |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_ServiceSetPermissions_Name, |
| Flags: bindings.MessageExpectsResponseFlag, |
| RequestId: p.ids.Count(), |
| } |
| var message *bindings.Message |
| if message, err = bindings.EncodeMessage(header, payload); err != nil { |
| err = fmt.Errorf("can't encode request: %v", err.Error()) |
| p.Close_Proxy() |
| return |
| } |
| readResult := <-p.router.AcceptWithResponse(message) |
| if err = readResult.Error; err != nil { |
| p.Close_Proxy() |
| return |
| } |
| if readResult.Message.Header.Flags != bindings.MessageIsResponseFlag { |
| err = &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", readResult.Message.Header.Flags), |
| } |
| return |
| } |
| if got, want := readResult.Message.Header.Type, syncbase_ServiceSetPermissions_Name; got != want { |
| err = &bindings.ValidationError{bindings.MessageHeaderUnknownMethod, |
| fmt.Sprintf("invalid method in response: expected %v, got %v", want, got), |
| } |
| return |
| } |
| var response syncbase_ServiceSetPermissions_ResponseParams |
| if err = readResult.Message.DecodePayload(&response); err != nil { |
| p.Close_Proxy() |
| return |
| } |
| outErr = response.outErr |
| return |
| } |
| |
| type syncbase_AppCreate_Params struct { |
| inName string |
| inPerms Perms |
| } |
| |
| func (s *syncbase_AppCreate_Params) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(16, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.inName); err != nil { |
| return err |
| } |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.inPerms.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_AppCreate_Params_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{24, 0}, |
| } |
| |
| func (s *syncbase_AppCreate_Params) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_AppCreate_Params_Versions), func(i int) bool { |
| return syncbase_AppCreate_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_AppCreate_Params_Versions) { |
| if syncbase_AppCreate_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_AppCreate_Params_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.inName = value0 |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.inPerms.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| type syncbase_AppCreate_ResponseParams struct { |
| outErr Error |
| } |
| |
| func (s *syncbase_AppCreate_ResponseParams) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(8, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.outErr.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_AppCreate_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{16, 0}, |
| } |
| |
| func (s *syncbase_AppCreate_ResponseParams) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_AppCreate_ResponseParams_Versions), func(i int) bool { |
| return syncbase_AppCreate_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_AppCreate_ResponseParams_Versions) { |
| if syncbase_AppCreate_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_AppCreate_ResponseParams_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.outErr.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (p *Syncbase_Proxy) AppCreate(inName string, inPerms Perms) (outErr Error, err error) { |
| payload := &syncbase_AppCreate_Params{ |
| inName, |
| inPerms, |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_AppCreate_Name, |
| Flags: bindings.MessageExpectsResponseFlag, |
| RequestId: p.ids.Count(), |
| } |
| var message *bindings.Message |
| if message, err = bindings.EncodeMessage(header, payload); err != nil { |
| err = fmt.Errorf("can't encode request: %v", err.Error()) |
| p.Close_Proxy() |
| return |
| } |
| readResult := <-p.router.AcceptWithResponse(message) |
| if err = readResult.Error; err != nil { |
| p.Close_Proxy() |
| return |
| } |
| if readResult.Message.Header.Flags != bindings.MessageIsResponseFlag { |
| err = &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", readResult.Message.Header.Flags), |
| } |
| return |
| } |
| if got, want := readResult.Message.Header.Type, syncbase_AppCreate_Name; got != want { |
| err = &bindings.ValidationError{bindings.MessageHeaderUnknownMethod, |
| fmt.Sprintf("invalid method in response: expected %v, got %v", want, got), |
| } |
| return |
| } |
| var response syncbase_AppCreate_ResponseParams |
| if err = readResult.Message.DecodePayload(&response); err != nil { |
| p.Close_Proxy() |
| return |
| } |
| outErr = response.outErr |
| return |
| } |
| |
| type syncbase_AppDelete_Params struct { |
| inName string |
| } |
| |
| func (s *syncbase_AppDelete_Params) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(8, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.inName); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_AppDelete_Params_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{16, 0}, |
| } |
| |
| func (s *syncbase_AppDelete_Params) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_AppDelete_Params_Versions), func(i int) bool { |
| return syncbase_AppDelete_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_AppDelete_Params_Versions) { |
| if syncbase_AppDelete_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_AppDelete_Params_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.inName = value0 |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| type syncbase_AppDelete_ResponseParams struct { |
| outErr Error |
| } |
| |
| func (s *syncbase_AppDelete_ResponseParams) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(8, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.outErr.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_AppDelete_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{16, 0}, |
| } |
| |
| func (s *syncbase_AppDelete_ResponseParams) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_AppDelete_ResponseParams_Versions), func(i int) bool { |
| return syncbase_AppDelete_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_AppDelete_ResponseParams_Versions) { |
| if syncbase_AppDelete_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_AppDelete_ResponseParams_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.outErr.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (p *Syncbase_Proxy) AppDelete(inName string) (outErr Error, err error) { |
| payload := &syncbase_AppDelete_Params{ |
| inName, |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_AppDelete_Name, |
| Flags: bindings.MessageExpectsResponseFlag, |
| RequestId: p.ids.Count(), |
| } |
| var message *bindings.Message |
| if message, err = bindings.EncodeMessage(header, payload); err != nil { |
| err = fmt.Errorf("can't encode request: %v", err.Error()) |
| p.Close_Proxy() |
| return |
| } |
| readResult := <-p.router.AcceptWithResponse(message) |
| if err = readResult.Error; err != nil { |
| p.Close_Proxy() |
| return |
| } |
| if readResult.Message.Header.Flags != bindings.MessageIsResponseFlag { |
| err = &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", readResult.Message.Header.Flags), |
| } |
| return |
| } |
| if got, want := readResult.Message.Header.Type, syncbase_AppDelete_Name; got != want { |
| err = &bindings.ValidationError{bindings.MessageHeaderUnknownMethod, |
| fmt.Sprintf("invalid method in response: expected %v, got %v", want, got), |
| } |
| return |
| } |
| var response syncbase_AppDelete_ResponseParams |
| if err = readResult.Message.DecodePayload(&response); err != nil { |
| p.Close_Proxy() |
| return |
| } |
| outErr = response.outErr |
| return |
| } |
| |
| type syncbase_AppExists_Params struct { |
| inName string |
| } |
| |
| func (s *syncbase_AppExists_Params) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(8, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.inName); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_AppExists_Params_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{16, 0}, |
| } |
| |
| func (s *syncbase_AppExists_Params) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_AppExists_Params_Versions), func(i int) bool { |
| return syncbase_AppExists_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_AppExists_Params_Versions) { |
| if syncbase_AppExists_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_AppExists_Params_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.inName = value0 |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| type syncbase_AppExists_ResponseParams struct { |
| outErr Error |
| outExists bool |
| } |
| |
| func (s *syncbase_AppExists_ResponseParams) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(16, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.outErr.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.WriteBool(s.outExists); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_AppExists_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{24, 0}, |
| } |
| |
| func (s *syncbase_AppExists_ResponseParams) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_AppExists_ResponseParams_Versions), func(i int) bool { |
| return syncbase_AppExists_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_AppExists_ResponseParams_Versions) { |
| if syncbase_AppExists_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_AppExists_ResponseParams_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.outErr.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| value0, err := decoder.ReadBool() |
| if err != nil { |
| return err |
| } |
| s.outExists = value0 |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (p *Syncbase_Proxy) AppExists(inName string) (outErr Error, outExists bool, err error) { |
| payload := &syncbase_AppExists_Params{ |
| inName, |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_AppExists_Name, |
| Flags: bindings.MessageExpectsResponseFlag, |
| RequestId: p.ids.Count(), |
| } |
| var message *bindings.Message |
| if message, err = bindings.EncodeMessage(header, payload); err != nil { |
| err = fmt.Errorf("can't encode request: %v", err.Error()) |
| p.Close_Proxy() |
| return |
| } |
| readResult := <-p.router.AcceptWithResponse(message) |
| if err = readResult.Error; err != nil { |
| p.Close_Proxy() |
| return |
| } |
| if readResult.Message.Header.Flags != bindings.MessageIsResponseFlag { |
| err = &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", readResult.Message.Header.Flags), |
| } |
| return |
| } |
| if got, want := readResult.Message.Header.Type, syncbase_AppExists_Name; got != want { |
| err = &bindings.ValidationError{bindings.MessageHeaderUnknownMethod, |
| fmt.Sprintf("invalid method in response: expected %v, got %v", want, got), |
| } |
| return |
| } |
| var response syncbase_AppExists_ResponseParams |
| if err = readResult.Message.DecodePayload(&response); err != nil { |
| p.Close_Proxy() |
| return |
| } |
| outErr = response.outErr |
| outExists = response.outExists |
| return |
| } |
| |
| type syncbase_AppGetPermissions_Params struct { |
| inName string |
| } |
| |
| func (s *syncbase_AppGetPermissions_Params) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(8, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.inName); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_AppGetPermissions_Params_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{16, 0}, |
| } |
| |
| func (s *syncbase_AppGetPermissions_Params) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_AppGetPermissions_Params_Versions), func(i int) bool { |
| return syncbase_AppGetPermissions_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_AppGetPermissions_Params_Versions) { |
| if syncbase_AppGetPermissions_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_AppGetPermissions_Params_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.inName = value0 |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| type syncbase_AppGetPermissions_ResponseParams struct { |
| outErr Error |
| outPerms Perms |
| outVersion string |
| } |
| |
| func (s *syncbase_AppGetPermissions_ResponseParams) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(24, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.outErr.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.outPerms.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.outVersion); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_AppGetPermissions_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{32, 0}, |
| } |
| |
| func (s *syncbase_AppGetPermissions_ResponseParams) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_AppGetPermissions_ResponseParams_Versions), func(i int) bool { |
| return syncbase_AppGetPermissions_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_AppGetPermissions_ResponseParams_Versions) { |
| if syncbase_AppGetPermissions_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_AppGetPermissions_ResponseParams_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.outErr.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.outPerms.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.outVersion = value0 |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (p *Syncbase_Proxy) AppGetPermissions(inName string) (outErr Error, outPerms Perms, outVersion string, err error) { |
| payload := &syncbase_AppGetPermissions_Params{ |
| inName, |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_AppGetPermissions_Name, |
| Flags: bindings.MessageExpectsResponseFlag, |
| RequestId: p.ids.Count(), |
| } |
| var message *bindings.Message |
| if message, err = bindings.EncodeMessage(header, payload); err != nil { |
| err = fmt.Errorf("can't encode request: %v", err.Error()) |
| p.Close_Proxy() |
| return |
| } |
| readResult := <-p.router.AcceptWithResponse(message) |
| if err = readResult.Error; err != nil { |
| p.Close_Proxy() |
| return |
| } |
| if readResult.Message.Header.Flags != bindings.MessageIsResponseFlag { |
| err = &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", readResult.Message.Header.Flags), |
| } |
| return |
| } |
| if got, want := readResult.Message.Header.Type, syncbase_AppGetPermissions_Name; got != want { |
| err = &bindings.ValidationError{bindings.MessageHeaderUnknownMethod, |
| fmt.Sprintf("invalid method in response: expected %v, got %v", want, got), |
| } |
| return |
| } |
| var response syncbase_AppGetPermissions_ResponseParams |
| if err = readResult.Message.DecodePayload(&response); err != nil { |
| p.Close_Proxy() |
| return |
| } |
| outErr = response.outErr |
| outPerms = response.outPerms |
| outVersion = response.outVersion |
| return |
| } |
| |
| type syncbase_AppSetPermissions_Params struct { |
| inName string |
| inPerms Perms |
| inVersion string |
| } |
| |
| func (s *syncbase_AppSetPermissions_Params) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(24, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.inName); err != nil { |
| return err |
| } |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.inPerms.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.inVersion); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_AppSetPermissions_Params_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{32, 0}, |
| } |
| |
| func (s *syncbase_AppSetPermissions_Params) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_AppSetPermissions_Params_Versions), func(i int) bool { |
| return syncbase_AppSetPermissions_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_AppSetPermissions_Params_Versions) { |
| if syncbase_AppSetPermissions_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_AppSetPermissions_Params_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.inName = value0 |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.inPerms.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.inVersion = value0 |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| type syncbase_AppSetPermissions_ResponseParams struct { |
| outErr Error |
| } |
| |
| func (s *syncbase_AppSetPermissions_ResponseParams) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(8, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.outErr.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_AppSetPermissions_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{16, 0}, |
| } |
| |
| func (s *syncbase_AppSetPermissions_ResponseParams) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_AppSetPermissions_ResponseParams_Versions), func(i int) bool { |
| return syncbase_AppSetPermissions_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_AppSetPermissions_ResponseParams_Versions) { |
| if syncbase_AppSetPermissions_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_AppSetPermissions_ResponseParams_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.outErr.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (p *Syncbase_Proxy) AppSetPermissions(inName string, inPerms Perms, inVersion string) (outErr Error, err error) { |
| payload := &syncbase_AppSetPermissions_Params{ |
| inName, |
| inPerms, |
| inVersion, |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_AppSetPermissions_Name, |
| Flags: bindings.MessageExpectsResponseFlag, |
| RequestId: p.ids.Count(), |
| } |
| var message *bindings.Message |
| if message, err = bindings.EncodeMessage(header, payload); err != nil { |
| err = fmt.Errorf("can't encode request: %v", err.Error()) |
| p.Close_Proxy() |
| return |
| } |
| readResult := <-p.router.AcceptWithResponse(message) |
| if err = readResult.Error; err != nil { |
| p.Close_Proxy() |
| return |
| } |
| if readResult.Message.Header.Flags != bindings.MessageIsResponseFlag { |
| err = &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", readResult.Message.Header.Flags), |
| } |
| return |
| } |
| if got, want := readResult.Message.Header.Type, syncbase_AppSetPermissions_Name; got != want { |
| err = &bindings.ValidationError{bindings.MessageHeaderUnknownMethod, |
| fmt.Sprintf("invalid method in response: expected %v, got %v", want, got), |
| } |
| return |
| } |
| var response syncbase_AppSetPermissions_ResponseParams |
| if err = readResult.Message.DecodePayload(&response); err != nil { |
| p.Close_Proxy() |
| return |
| } |
| outErr = response.outErr |
| return |
| } |
| |
| type syncbase_DbCreate_Params struct { |
| inName string |
| inPerms Perms |
| } |
| |
| func (s *syncbase_DbCreate_Params) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(16, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.inName); err != nil { |
| return err |
| } |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.inPerms.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_DbCreate_Params_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{24, 0}, |
| } |
| |
| func (s *syncbase_DbCreate_Params) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_DbCreate_Params_Versions), func(i int) bool { |
| return syncbase_DbCreate_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_DbCreate_Params_Versions) { |
| if syncbase_DbCreate_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_DbCreate_Params_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.inName = value0 |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.inPerms.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| type syncbase_DbCreate_ResponseParams struct { |
| outErr Error |
| } |
| |
| func (s *syncbase_DbCreate_ResponseParams) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(8, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.outErr.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_DbCreate_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{16, 0}, |
| } |
| |
| func (s *syncbase_DbCreate_ResponseParams) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_DbCreate_ResponseParams_Versions), func(i int) bool { |
| return syncbase_DbCreate_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_DbCreate_ResponseParams_Versions) { |
| if syncbase_DbCreate_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_DbCreate_ResponseParams_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.outErr.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (p *Syncbase_Proxy) DbCreate(inName string, inPerms Perms) (outErr Error, err error) { |
| payload := &syncbase_DbCreate_Params{ |
| inName, |
| inPerms, |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_DbCreate_Name, |
| Flags: bindings.MessageExpectsResponseFlag, |
| RequestId: p.ids.Count(), |
| } |
| var message *bindings.Message |
| if message, err = bindings.EncodeMessage(header, payload); err != nil { |
| err = fmt.Errorf("can't encode request: %v", err.Error()) |
| p.Close_Proxy() |
| return |
| } |
| readResult := <-p.router.AcceptWithResponse(message) |
| if err = readResult.Error; err != nil { |
| p.Close_Proxy() |
| return |
| } |
| if readResult.Message.Header.Flags != bindings.MessageIsResponseFlag { |
| err = &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", readResult.Message.Header.Flags), |
| } |
| return |
| } |
| if got, want := readResult.Message.Header.Type, syncbase_DbCreate_Name; got != want { |
| err = &bindings.ValidationError{bindings.MessageHeaderUnknownMethod, |
| fmt.Sprintf("invalid method in response: expected %v, got %v", want, got), |
| } |
| return |
| } |
| var response syncbase_DbCreate_ResponseParams |
| if err = readResult.Message.DecodePayload(&response); err != nil { |
| p.Close_Proxy() |
| return |
| } |
| outErr = response.outErr |
| return |
| } |
| |
| type syncbase_DbDelete_Params struct { |
| inName string |
| } |
| |
| func (s *syncbase_DbDelete_Params) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(8, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.inName); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_DbDelete_Params_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{16, 0}, |
| } |
| |
| func (s *syncbase_DbDelete_Params) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_DbDelete_Params_Versions), func(i int) bool { |
| return syncbase_DbDelete_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_DbDelete_Params_Versions) { |
| if syncbase_DbDelete_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_DbDelete_Params_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.inName = value0 |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| type syncbase_DbDelete_ResponseParams struct { |
| outErr Error |
| } |
| |
| func (s *syncbase_DbDelete_ResponseParams) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(8, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.outErr.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_DbDelete_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{16, 0}, |
| } |
| |
| func (s *syncbase_DbDelete_ResponseParams) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_DbDelete_ResponseParams_Versions), func(i int) bool { |
| return syncbase_DbDelete_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_DbDelete_ResponseParams_Versions) { |
| if syncbase_DbDelete_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_DbDelete_ResponseParams_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.outErr.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (p *Syncbase_Proxy) DbDelete(inName string) (outErr Error, err error) { |
| payload := &syncbase_DbDelete_Params{ |
| inName, |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_DbDelete_Name, |
| Flags: bindings.MessageExpectsResponseFlag, |
| RequestId: p.ids.Count(), |
| } |
| var message *bindings.Message |
| if message, err = bindings.EncodeMessage(header, payload); err != nil { |
| err = fmt.Errorf("can't encode request: %v", err.Error()) |
| p.Close_Proxy() |
| return |
| } |
| readResult := <-p.router.AcceptWithResponse(message) |
| if err = readResult.Error; err != nil { |
| p.Close_Proxy() |
| return |
| } |
| if readResult.Message.Header.Flags != bindings.MessageIsResponseFlag { |
| err = &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", readResult.Message.Header.Flags), |
| } |
| return |
| } |
| if got, want := readResult.Message.Header.Type, syncbase_DbDelete_Name; got != want { |
| err = &bindings.ValidationError{bindings.MessageHeaderUnknownMethod, |
| fmt.Sprintf("invalid method in response: expected %v, got %v", want, got), |
| } |
| return |
| } |
| var response syncbase_DbDelete_ResponseParams |
| if err = readResult.Message.DecodePayload(&response); err != nil { |
| p.Close_Proxy() |
| return |
| } |
| outErr = response.outErr |
| return |
| } |
| |
| type syncbase_DbExists_Params struct { |
| inName string |
| } |
| |
| func (s *syncbase_DbExists_Params) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(8, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.inName); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_DbExists_Params_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{16, 0}, |
| } |
| |
| func (s *syncbase_DbExists_Params) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_DbExists_Params_Versions), func(i int) bool { |
| return syncbase_DbExists_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_DbExists_Params_Versions) { |
| if syncbase_DbExists_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_DbExists_Params_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.inName = value0 |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| type syncbase_DbExists_ResponseParams struct { |
| outErr Error |
| outExists bool |
| } |
| |
| func (s *syncbase_DbExists_ResponseParams) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(16, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.outErr.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.WriteBool(s.outExists); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_DbExists_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{24, 0}, |
| } |
| |
| func (s *syncbase_DbExists_ResponseParams) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_DbExists_ResponseParams_Versions), func(i int) bool { |
| return syncbase_DbExists_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_DbExists_ResponseParams_Versions) { |
| if syncbase_DbExists_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_DbExists_ResponseParams_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.outErr.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| value0, err := decoder.ReadBool() |
| if err != nil { |
| return err |
| } |
| s.outExists = value0 |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (p *Syncbase_Proxy) DbExists(inName string) (outErr Error, outExists bool, err error) { |
| payload := &syncbase_DbExists_Params{ |
| inName, |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_DbExists_Name, |
| Flags: bindings.MessageExpectsResponseFlag, |
| RequestId: p.ids.Count(), |
| } |
| var message *bindings.Message |
| if message, err = bindings.EncodeMessage(header, payload); err != nil { |
| err = fmt.Errorf("can't encode request: %v", err.Error()) |
| p.Close_Proxy() |
| return |
| } |
| readResult := <-p.router.AcceptWithResponse(message) |
| if err = readResult.Error; err != nil { |
| p.Close_Proxy() |
| return |
| } |
| if readResult.Message.Header.Flags != bindings.MessageIsResponseFlag { |
| err = &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", readResult.Message.Header.Flags), |
| } |
| return |
| } |
| if got, want := readResult.Message.Header.Type, syncbase_DbExists_Name; got != want { |
| err = &bindings.ValidationError{bindings.MessageHeaderUnknownMethod, |
| fmt.Sprintf("invalid method in response: expected %v, got %v", want, got), |
| } |
| return |
| } |
| var response syncbase_DbExists_ResponseParams |
| if err = readResult.Message.DecodePayload(&response); err != nil { |
| p.Close_Proxy() |
| return |
| } |
| outErr = response.outErr |
| outExists = response.outExists |
| return |
| } |
| |
| type syncbase_DbExec_Params struct { |
| inQuery string |
| } |
| |
| func (s *syncbase_DbExec_Params) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(8, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.inQuery); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_DbExec_Params_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{16, 0}, |
| } |
| |
| func (s *syncbase_DbExec_Params) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_DbExec_Params_Versions), func(i int) bool { |
| return syncbase_DbExec_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_DbExec_Params_Versions) { |
| if syncbase_DbExec_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_DbExec_Params_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.inQuery = value0 |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| type syncbase_DbExec_ResponseParams struct { |
| outErr Error |
| } |
| |
| func (s *syncbase_DbExec_ResponseParams) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(8, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.outErr.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_DbExec_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{16, 0}, |
| } |
| |
| func (s *syncbase_DbExec_ResponseParams) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_DbExec_ResponseParams_Versions), func(i int) bool { |
| return syncbase_DbExec_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_DbExec_ResponseParams_Versions) { |
| if syncbase_DbExec_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_DbExec_ResponseParams_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.outErr.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (p *Syncbase_Proxy) DbExec(inQuery string) (outErr Error, err error) { |
| payload := &syncbase_DbExec_Params{ |
| inQuery, |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_DbExec_Name, |
| Flags: bindings.MessageExpectsResponseFlag, |
| RequestId: p.ids.Count(), |
| } |
| var message *bindings.Message |
| if message, err = bindings.EncodeMessage(header, payload); err != nil { |
| err = fmt.Errorf("can't encode request: %v", err.Error()) |
| p.Close_Proxy() |
| return |
| } |
| readResult := <-p.router.AcceptWithResponse(message) |
| if err = readResult.Error; err != nil { |
| p.Close_Proxy() |
| return |
| } |
| if readResult.Message.Header.Flags != bindings.MessageIsResponseFlag { |
| err = &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", readResult.Message.Header.Flags), |
| } |
| return |
| } |
| if got, want := readResult.Message.Header.Type, syncbase_DbExec_Name; got != want { |
| err = &bindings.ValidationError{bindings.MessageHeaderUnknownMethod, |
| fmt.Sprintf("invalid method in response: expected %v, got %v", want, got), |
| } |
| return |
| } |
| var response syncbase_DbExec_ResponseParams |
| if err = readResult.Message.DecodePayload(&response); err != nil { |
| p.Close_Proxy() |
| return |
| } |
| outErr = response.outErr |
| return |
| } |
| |
| type syncbase_DbBeginBatch_Params struct { |
| inName string |
| inBo *BatchOptions |
| } |
| |
| func (s *syncbase_DbBeginBatch_Params) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(16, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.inName); err != nil { |
| return err |
| } |
| if s.inBo == nil { |
| encoder.WriteNullPointer() |
| } else { |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := (*s.inBo).Encode(encoder); err != nil { |
| return err |
| } |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_DbBeginBatch_Params_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{24, 0}, |
| } |
| |
| func (s *syncbase_DbBeginBatch_Params) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_DbBeginBatch_Params_Versions), func(i int) bool { |
| return syncbase_DbBeginBatch_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_DbBeginBatch_Params_Versions) { |
| if syncbase_DbBeginBatch_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_DbBeginBatch_Params_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.inName = value0 |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| s.inBo = nil |
| } else { |
| s.inBo = new(BatchOptions) |
| if err := (*s.inBo).Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| type syncbase_DbBeginBatch_ResponseParams struct { |
| outErr Error |
| outBatchDn string |
| } |
| |
| func (s *syncbase_DbBeginBatch_ResponseParams) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(16, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.outErr.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.outBatchDn); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_DbBeginBatch_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{24, 0}, |
| } |
| |
| func (s *syncbase_DbBeginBatch_ResponseParams) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_DbBeginBatch_ResponseParams_Versions), func(i int) bool { |
| return syncbase_DbBeginBatch_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_DbBeginBatch_ResponseParams_Versions) { |
| if syncbase_DbBeginBatch_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_DbBeginBatch_ResponseParams_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.outErr.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.outBatchDn = value0 |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (p *Syncbase_Proxy) DbBeginBatch(inName string, inBo *BatchOptions) (outErr Error, outBatchDn string, err error) { |
| payload := &syncbase_DbBeginBatch_Params{ |
| inName, |
| inBo, |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_DbBeginBatch_Name, |
| Flags: bindings.MessageExpectsResponseFlag, |
| RequestId: p.ids.Count(), |
| } |
| var message *bindings.Message |
| if message, err = bindings.EncodeMessage(header, payload); err != nil { |
| err = fmt.Errorf("can't encode request: %v", err.Error()) |
| p.Close_Proxy() |
| return |
| } |
| readResult := <-p.router.AcceptWithResponse(message) |
| if err = readResult.Error; err != nil { |
| p.Close_Proxy() |
| return |
| } |
| if readResult.Message.Header.Flags != bindings.MessageIsResponseFlag { |
| err = &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", readResult.Message.Header.Flags), |
| } |
| return |
| } |
| if got, want := readResult.Message.Header.Type, syncbase_DbBeginBatch_Name; got != want { |
| err = &bindings.ValidationError{bindings.MessageHeaderUnknownMethod, |
| fmt.Sprintf("invalid method in response: expected %v, got %v", want, got), |
| } |
| return |
| } |
| var response syncbase_DbBeginBatch_ResponseParams |
| if err = readResult.Message.DecodePayload(&response); err != nil { |
| p.Close_Proxy() |
| return |
| } |
| outErr = response.outErr |
| outBatchDn = response.outBatchDn |
| return |
| } |
| |
| type syncbase_DbCommit_Params struct { |
| inName string |
| } |
| |
| func (s *syncbase_DbCommit_Params) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(8, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.inName); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_DbCommit_Params_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{16, 0}, |
| } |
| |
| func (s *syncbase_DbCommit_Params) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_DbCommit_Params_Versions), func(i int) bool { |
| return syncbase_DbCommit_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_DbCommit_Params_Versions) { |
| if syncbase_DbCommit_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_DbCommit_Params_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.inName = value0 |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| type syncbase_DbCommit_ResponseParams struct { |
| outErr Error |
| } |
| |
| func (s *syncbase_DbCommit_ResponseParams) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(8, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.outErr.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_DbCommit_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{16, 0}, |
| } |
| |
| func (s *syncbase_DbCommit_ResponseParams) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_DbCommit_ResponseParams_Versions), func(i int) bool { |
| return syncbase_DbCommit_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_DbCommit_ResponseParams_Versions) { |
| if syncbase_DbCommit_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_DbCommit_ResponseParams_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.outErr.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (p *Syncbase_Proxy) DbCommit(inName string) (outErr Error, err error) { |
| payload := &syncbase_DbCommit_Params{ |
| inName, |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_DbCommit_Name, |
| Flags: bindings.MessageExpectsResponseFlag, |
| RequestId: p.ids.Count(), |
| } |
| var message *bindings.Message |
| if message, err = bindings.EncodeMessage(header, payload); err != nil { |
| err = fmt.Errorf("can't encode request: %v", err.Error()) |
| p.Close_Proxy() |
| return |
| } |
| readResult := <-p.router.AcceptWithResponse(message) |
| if err = readResult.Error; err != nil { |
| p.Close_Proxy() |
| return |
| } |
| if readResult.Message.Header.Flags != bindings.MessageIsResponseFlag { |
| err = &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", readResult.Message.Header.Flags), |
| } |
| return |
| } |
| if got, want := readResult.Message.Header.Type, syncbase_DbCommit_Name; got != want { |
| err = &bindings.ValidationError{bindings.MessageHeaderUnknownMethod, |
| fmt.Sprintf("invalid method in response: expected %v, got %v", want, got), |
| } |
| return |
| } |
| var response syncbase_DbCommit_ResponseParams |
| if err = readResult.Message.DecodePayload(&response); err != nil { |
| p.Close_Proxy() |
| return |
| } |
| outErr = response.outErr |
| return |
| } |
| |
| type syncbase_DbAbort_Params struct { |
| inName string |
| } |
| |
| func (s *syncbase_DbAbort_Params) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(8, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.inName); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_DbAbort_Params_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{16, 0}, |
| } |
| |
| func (s *syncbase_DbAbort_Params) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_DbAbort_Params_Versions), func(i int) bool { |
| return syncbase_DbAbort_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_DbAbort_Params_Versions) { |
| if syncbase_DbAbort_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_DbAbort_Params_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.inName = value0 |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| type syncbase_DbAbort_ResponseParams struct { |
| outErr Error |
| } |
| |
| func (s *syncbase_DbAbort_ResponseParams) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(8, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.outErr.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_DbAbort_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{16, 0}, |
| } |
| |
| func (s *syncbase_DbAbort_ResponseParams) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_DbAbort_ResponseParams_Versions), func(i int) bool { |
| return syncbase_DbAbort_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_DbAbort_ResponseParams_Versions) { |
| if syncbase_DbAbort_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_DbAbort_ResponseParams_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.outErr.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (p *Syncbase_Proxy) DbAbort(inName string) (outErr Error, err error) { |
| payload := &syncbase_DbAbort_Params{ |
| inName, |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_DbAbort_Name, |
| Flags: bindings.MessageExpectsResponseFlag, |
| RequestId: p.ids.Count(), |
| } |
| var message *bindings.Message |
| if message, err = bindings.EncodeMessage(header, payload); err != nil { |
| err = fmt.Errorf("can't encode request: %v", err.Error()) |
| p.Close_Proxy() |
| return |
| } |
| readResult := <-p.router.AcceptWithResponse(message) |
| if err = readResult.Error; err != nil { |
| p.Close_Proxy() |
| return |
| } |
| if readResult.Message.Header.Flags != bindings.MessageIsResponseFlag { |
| err = &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", readResult.Message.Header.Flags), |
| } |
| return |
| } |
| if got, want := readResult.Message.Header.Type, syncbase_DbAbort_Name; got != want { |
| err = &bindings.ValidationError{bindings.MessageHeaderUnknownMethod, |
| fmt.Sprintf("invalid method in response: expected %v, got %v", want, got), |
| } |
| return |
| } |
| var response syncbase_DbAbort_ResponseParams |
| if err = readResult.Message.DecodePayload(&response); err != nil { |
| p.Close_Proxy() |
| return |
| } |
| outErr = response.outErr |
| return |
| } |
| |
| type syncbase_DbGetPermissions_Params struct { |
| inName string |
| } |
| |
| func (s *syncbase_DbGetPermissions_Params) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(8, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.inName); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_DbGetPermissions_Params_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{16, 0}, |
| } |
| |
| func (s *syncbase_DbGetPermissions_Params) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_DbGetPermissions_Params_Versions), func(i int) bool { |
| return syncbase_DbGetPermissions_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_DbGetPermissions_Params_Versions) { |
| if syncbase_DbGetPermissions_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_DbGetPermissions_Params_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.inName = value0 |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| type syncbase_DbGetPermissions_ResponseParams struct { |
| outErr Error |
| outPerms Perms |
| outVersion string |
| } |
| |
| func (s *syncbase_DbGetPermissions_ResponseParams) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(24, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.outErr.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.outPerms.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.outVersion); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_DbGetPermissions_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{32, 0}, |
| } |
| |
| func (s *syncbase_DbGetPermissions_ResponseParams) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_DbGetPermissions_ResponseParams_Versions), func(i int) bool { |
| return syncbase_DbGetPermissions_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_DbGetPermissions_ResponseParams_Versions) { |
| if syncbase_DbGetPermissions_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_DbGetPermissions_ResponseParams_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.outErr.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.outPerms.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.outVersion = value0 |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (p *Syncbase_Proxy) DbGetPermissions(inName string) (outErr Error, outPerms Perms, outVersion string, err error) { |
| payload := &syncbase_DbGetPermissions_Params{ |
| inName, |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_DbGetPermissions_Name, |
| Flags: bindings.MessageExpectsResponseFlag, |
| RequestId: p.ids.Count(), |
| } |
| var message *bindings.Message |
| if message, err = bindings.EncodeMessage(header, payload); err != nil { |
| err = fmt.Errorf("can't encode request: %v", err.Error()) |
| p.Close_Proxy() |
| return |
| } |
| readResult := <-p.router.AcceptWithResponse(message) |
| if err = readResult.Error; err != nil { |
| p.Close_Proxy() |
| return |
| } |
| if readResult.Message.Header.Flags != bindings.MessageIsResponseFlag { |
| err = &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", readResult.Message.Header.Flags), |
| } |
| return |
| } |
| if got, want := readResult.Message.Header.Type, syncbase_DbGetPermissions_Name; got != want { |
| err = &bindings.ValidationError{bindings.MessageHeaderUnknownMethod, |
| fmt.Sprintf("invalid method in response: expected %v, got %v", want, got), |
| } |
| return |
| } |
| var response syncbase_DbGetPermissions_ResponseParams |
| if err = readResult.Message.DecodePayload(&response); err != nil { |
| p.Close_Proxy() |
| return |
| } |
| outErr = response.outErr |
| outPerms = response.outPerms |
| outVersion = response.outVersion |
| return |
| } |
| |
| type syncbase_DbSetPermissions_Params struct { |
| inName string |
| inPerms Perms |
| inVersion string |
| } |
| |
| func (s *syncbase_DbSetPermissions_Params) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(24, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.inName); err != nil { |
| return err |
| } |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.inPerms.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.inVersion); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_DbSetPermissions_Params_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{32, 0}, |
| } |
| |
| func (s *syncbase_DbSetPermissions_Params) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_DbSetPermissions_Params_Versions), func(i int) bool { |
| return syncbase_DbSetPermissions_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_DbSetPermissions_Params_Versions) { |
| if syncbase_DbSetPermissions_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_DbSetPermissions_Params_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.inName = value0 |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.inPerms.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.inVersion = value0 |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| type syncbase_DbSetPermissions_ResponseParams struct { |
| outErr Error |
| } |
| |
| func (s *syncbase_DbSetPermissions_ResponseParams) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(8, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.outErr.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_DbSetPermissions_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{16, 0}, |
| } |
| |
| func (s *syncbase_DbSetPermissions_ResponseParams) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_DbSetPermissions_ResponseParams_Versions), func(i int) bool { |
| return syncbase_DbSetPermissions_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_DbSetPermissions_ResponseParams_Versions) { |
| if syncbase_DbSetPermissions_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_DbSetPermissions_ResponseParams_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.outErr.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (p *Syncbase_Proxy) DbSetPermissions(inName string, inPerms Perms, inVersion string) (outErr Error, err error) { |
| payload := &syncbase_DbSetPermissions_Params{ |
| inName, |
| inPerms, |
| inVersion, |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_DbSetPermissions_Name, |
| Flags: bindings.MessageExpectsResponseFlag, |
| RequestId: p.ids.Count(), |
| } |
| var message *bindings.Message |
| if message, err = bindings.EncodeMessage(header, payload); err != nil { |
| err = fmt.Errorf("can't encode request: %v", err.Error()) |
| p.Close_Proxy() |
| return |
| } |
| readResult := <-p.router.AcceptWithResponse(message) |
| if err = readResult.Error; err != nil { |
| p.Close_Proxy() |
| return |
| } |
| if readResult.Message.Header.Flags != bindings.MessageIsResponseFlag { |
| err = &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", readResult.Message.Header.Flags), |
| } |
| return |
| } |
| if got, want := readResult.Message.Header.Type, syncbase_DbSetPermissions_Name; got != want { |
| err = &bindings.ValidationError{bindings.MessageHeaderUnknownMethod, |
| fmt.Sprintf("invalid method in response: expected %v, got %v", want, got), |
| } |
| return |
| } |
| var response syncbase_DbSetPermissions_ResponseParams |
| if err = readResult.Message.DecodePayload(&response); err != nil { |
| p.Close_Proxy() |
| return |
| } |
| outErr = response.outErr |
| return |
| } |
| |
| type syncbase_DbGetSyncGroupNames_Params struct { |
| inName string |
| } |
| |
| func (s *syncbase_DbGetSyncGroupNames_Params) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(8, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.inName); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_DbGetSyncGroupNames_Params_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{16, 0}, |
| } |
| |
| func (s *syncbase_DbGetSyncGroupNames_Params) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_DbGetSyncGroupNames_Params_Versions), func(i int) bool { |
| return syncbase_DbGetSyncGroupNames_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_DbGetSyncGroupNames_Params_Versions) { |
| if syncbase_DbGetSyncGroupNames_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_DbGetSyncGroupNames_Params_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.inName = value0 |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| type syncbase_DbGetSyncGroupNames_ResponseParams struct { |
| outErr Error |
| outNames []string |
| } |
| |
| func (s *syncbase_DbGetSyncGroupNames_ResponseParams) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(16, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.outErr.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| encoder.StartArray(uint32(len(s.outNames)), 64) |
| for _, elem0 := range s.outNames { |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(elem0); err != nil { |
| return err |
| } |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_DbGetSyncGroupNames_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{24, 0}, |
| } |
| |
| func (s *syncbase_DbGetSyncGroupNames_ResponseParams) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_DbGetSyncGroupNames_ResponseParams_Versions), func(i int) bool { |
| return syncbase_DbGetSyncGroupNames_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_DbGetSyncGroupNames_ResponseParams_Versions) { |
| if syncbase_DbGetSyncGroupNames_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_DbGetSyncGroupNames_ResponseParams_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.outErr.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| len0, err := decoder.StartArray(64) |
| if err != nil { |
| return err |
| } |
| s.outNames = make([]string, len0) |
| for i0 := uint32(0); i0 < len0; i0++ { |
| pointer1, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer1 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value1, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.outNames[i0] = value1 |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (p *Syncbase_Proxy) DbGetSyncGroupNames(inName string) (outErr Error, outNames []string, err error) { |
| payload := &syncbase_DbGetSyncGroupNames_Params{ |
| inName, |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_DbGetSyncGroupNames_Name, |
| Flags: bindings.MessageExpectsResponseFlag, |
| RequestId: p.ids.Count(), |
| } |
| var message *bindings.Message |
| if message, err = bindings.EncodeMessage(header, payload); err != nil { |
| err = fmt.Errorf("can't encode request: %v", err.Error()) |
| p.Close_Proxy() |
| return |
| } |
| readResult := <-p.router.AcceptWithResponse(message) |
| if err = readResult.Error; err != nil { |
| p.Close_Proxy() |
| return |
| } |
| if readResult.Message.Header.Flags != bindings.MessageIsResponseFlag { |
| err = &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", readResult.Message.Header.Flags), |
| } |
| return |
| } |
| if got, want := readResult.Message.Header.Type, syncbase_DbGetSyncGroupNames_Name; got != want { |
| err = &bindings.ValidationError{bindings.MessageHeaderUnknownMethod, |
| fmt.Sprintf("invalid method in response: expected %v, got %v", want, got), |
| } |
| return |
| } |
| var response syncbase_DbGetSyncGroupNames_ResponseParams |
| if err = readResult.Message.DecodePayload(&response); err != nil { |
| p.Close_Proxy() |
| return |
| } |
| outErr = response.outErr |
| outNames = response.outNames |
| return |
| } |
| |
| type syncbase_DbCreateSyncGroup_Params struct { |
| inName string |
| inSgName string |
| inSpec SyncGroupSpec |
| inMyInfo SyncGroupMemberInfo |
| } |
| |
| func (s *syncbase_DbCreateSyncGroup_Params) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(32, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.inName); err != nil { |
| return err |
| } |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.inSgName); err != nil { |
| return err |
| } |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.inSpec.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.inMyInfo.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_DbCreateSyncGroup_Params_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{40, 0}, |
| } |
| |
| func (s *syncbase_DbCreateSyncGroup_Params) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_DbCreateSyncGroup_Params_Versions), func(i int) bool { |
| return syncbase_DbCreateSyncGroup_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_DbCreateSyncGroup_Params_Versions) { |
| if syncbase_DbCreateSyncGroup_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_DbCreateSyncGroup_Params_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.inName = value0 |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.inSgName = value0 |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.inSpec.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.inMyInfo.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| type syncbase_DbCreateSyncGroup_ResponseParams struct { |
| outErr Error |
| } |
| |
| func (s *syncbase_DbCreateSyncGroup_ResponseParams) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(8, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.outErr.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_DbCreateSyncGroup_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{16, 0}, |
| } |
| |
| func (s *syncbase_DbCreateSyncGroup_ResponseParams) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_DbCreateSyncGroup_ResponseParams_Versions), func(i int) bool { |
| return syncbase_DbCreateSyncGroup_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_DbCreateSyncGroup_ResponseParams_Versions) { |
| if syncbase_DbCreateSyncGroup_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_DbCreateSyncGroup_ResponseParams_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.outErr.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (p *Syncbase_Proxy) DbCreateSyncGroup(inName string, inSgName string, inSpec SyncGroupSpec, inMyInfo SyncGroupMemberInfo) (outErr Error, err error) { |
| payload := &syncbase_DbCreateSyncGroup_Params{ |
| inName, |
| inSgName, |
| inSpec, |
| inMyInfo, |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_DbCreateSyncGroup_Name, |
| Flags: bindings.MessageExpectsResponseFlag, |
| RequestId: p.ids.Count(), |
| } |
| var message *bindings.Message |
| if message, err = bindings.EncodeMessage(header, payload); err != nil { |
| err = fmt.Errorf("can't encode request: %v", err.Error()) |
| p.Close_Proxy() |
| return |
| } |
| readResult := <-p.router.AcceptWithResponse(message) |
| if err = readResult.Error; err != nil { |
| p.Close_Proxy() |
| return |
| } |
| if readResult.Message.Header.Flags != bindings.MessageIsResponseFlag { |
| err = &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", readResult.Message.Header.Flags), |
| } |
| return |
| } |
| if got, want := readResult.Message.Header.Type, syncbase_DbCreateSyncGroup_Name; got != want { |
| err = &bindings.ValidationError{bindings.MessageHeaderUnknownMethod, |
| fmt.Sprintf("invalid method in response: expected %v, got %v", want, got), |
| } |
| return |
| } |
| var response syncbase_DbCreateSyncGroup_ResponseParams |
| if err = readResult.Message.DecodePayload(&response); err != nil { |
| p.Close_Proxy() |
| return |
| } |
| outErr = response.outErr |
| return |
| } |
| |
| type syncbase_DbJoinSyncGroup_Params struct { |
| inName string |
| inSgName string |
| inMyInfo SyncGroupMemberInfo |
| } |
| |
| func (s *syncbase_DbJoinSyncGroup_Params) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(24, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.inName); err != nil { |
| return err |
| } |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.inSgName); err != nil { |
| return err |
| } |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.inMyInfo.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_DbJoinSyncGroup_Params_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{32, 0}, |
| } |
| |
| func (s *syncbase_DbJoinSyncGroup_Params) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_DbJoinSyncGroup_Params_Versions), func(i int) bool { |
| return syncbase_DbJoinSyncGroup_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_DbJoinSyncGroup_Params_Versions) { |
| if syncbase_DbJoinSyncGroup_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_DbJoinSyncGroup_Params_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.inName = value0 |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.inSgName = value0 |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.inMyInfo.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| type syncbase_DbJoinSyncGroup_ResponseParams struct { |
| outErr Error |
| } |
| |
| func (s *syncbase_DbJoinSyncGroup_ResponseParams) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(8, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.outErr.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_DbJoinSyncGroup_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{16, 0}, |
| } |
| |
| func (s *syncbase_DbJoinSyncGroup_ResponseParams) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_DbJoinSyncGroup_ResponseParams_Versions), func(i int) bool { |
| return syncbase_DbJoinSyncGroup_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_DbJoinSyncGroup_ResponseParams_Versions) { |
| if syncbase_DbJoinSyncGroup_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_DbJoinSyncGroup_ResponseParams_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.outErr.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (p *Syncbase_Proxy) DbJoinSyncGroup(inName string, inSgName string, inMyInfo SyncGroupMemberInfo) (outErr Error, err error) { |
| payload := &syncbase_DbJoinSyncGroup_Params{ |
| inName, |
| inSgName, |
| inMyInfo, |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_DbJoinSyncGroup_Name, |
| Flags: bindings.MessageExpectsResponseFlag, |
| RequestId: p.ids.Count(), |
| } |
| var message *bindings.Message |
| if message, err = bindings.EncodeMessage(header, payload); err != nil { |
| err = fmt.Errorf("can't encode request: %v", err.Error()) |
| p.Close_Proxy() |
| return |
| } |
| readResult := <-p.router.AcceptWithResponse(message) |
| if err = readResult.Error; err != nil { |
| p.Close_Proxy() |
| return |
| } |
| if readResult.Message.Header.Flags != bindings.MessageIsResponseFlag { |
| err = &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", readResult.Message.Header.Flags), |
| } |
| return |
| } |
| if got, want := readResult.Message.Header.Type, syncbase_DbJoinSyncGroup_Name; got != want { |
| err = &bindings.ValidationError{bindings.MessageHeaderUnknownMethod, |
| fmt.Sprintf("invalid method in response: expected %v, got %v", want, got), |
| } |
| return |
| } |
| var response syncbase_DbJoinSyncGroup_ResponseParams |
| if err = readResult.Message.DecodePayload(&response); err != nil { |
| p.Close_Proxy() |
| return |
| } |
| outErr = response.outErr |
| return |
| } |
| |
| type syncbase_DbLeaveSyncGroup_Params struct { |
| inName string |
| inSgName string |
| } |
| |
| func (s *syncbase_DbLeaveSyncGroup_Params) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(16, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.inName); err != nil { |
| return err |
| } |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.inSgName); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_DbLeaveSyncGroup_Params_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{24, 0}, |
| } |
| |
| func (s *syncbase_DbLeaveSyncGroup_Params) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_DbLeaveSyncGroup_Params_Versions), func(i int) bool { |
| return syncbase_DbLeaveSyncGroup_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_DbLeaveSyncGroup_Params_Versions) { |
| if syncbase_DbLeaveSyncGroup_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_DbLeaveSyncGroup_Params_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.inName = value0 |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.inSgName = value0 |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| type syncbase_DbLeaveSyncGroup_ResponseParams struct { |
| outErr Error |
| } |
| |
| func (s *syncbase_DbLeaveSyncGroup_ResponseParams) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(8, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.outErr.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_DbLeaveSyncGroup_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{16, 0}, |
| } |
| |
| func (s *syncbase_DbLeaveSyncGroup_ResponseParams) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_DbLeaveSyncGroup_ResponseParams_Versions), func(i int) bool { |
| return syncbase_DbLeaveSyncGroup_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_DbLeaveSyncGroup_ResponseParams_Versions) { |
| if syncbase_DbLeaveSyncGroup_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_DbLeaveSyncGroup_ResponseParams_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.outErr.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (p *Syncbase_Proxy) DbLeaveSyncGroup(inName string, inSgName string) (outErr Error, err error) { |
| payload := &syncbase_DbLeaveSyncGroup_Params{ |
| inName, |
| inSgName, |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_DbLeaveSyncGroup_Name, |
| Flags: bindings.MessageExpectsResponseFlag, |
| RequestId: p.ids.Count(), |
| } |
| var message *bindings.Message |
| if message, err = bindings.EncodeMessage(header, payload); err != nil { |
| err = fmt.Errorf("can't encode request: %v", err.Error()) |
| p.Close_Proxy() |
| return |
| } |
| readResult := <-p.router.AcceptWithResponse(message) |
| if err = readResult.Error; err != nil { |
| p.Close_Proxy() |
| return |
| } |
| if readResult.Message.Header.Flags != bindings.MessageIsResponseFlag { |
| err = &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", readResult.Message.Header.Flags), |
| } |
| return |
| } |
| if got, want := readResult.Message.Header.Type, syncbase_DbLeaveSyncGroup_Name; got != want { |
| err = &bindings.ValidationError{bindings.MessageHeaderUnknownMethod, |
| fmt.Sprintf("invalid method in response: expected %v, got %v", want, got), |
| } |
| return |
| } |
| var response syncbase_DbLeaveSyncGroup_ResponseParams |
| if err = readResult.Message.DecodePayload(&response); err != nil { |
| p.Close_Proxy() |
| return |
| } |
| outErr = response.outErr |
| return |
| } |
| |
| type syncbase_DbDestroySyncGroup_Params struct { |
| inName string |
| inSgName string |
| } |
| |
| func (s *syncbase_DbDestroySyncGroup_Params) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(16, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.inName); err != nil { |
| return err |
| } |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.inSgName); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_DbDestroySyncGroup_Params_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{24, 0}, |
| } |
| |
| func (s *syncbase_DbDestroySyncGroup_Params) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_DbDestroySyncGroup_Params_Versions), func(i int) bool { |
| return syncbase_DbDestroySyncGroup_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_DbDestroySyncGroup_Params_Versions) { |
| if syncbase_DbDestroySyncGroup_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_DbDestroySyncGroup_Params_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.inName = value0 |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.inSgName = value0 |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| type syncbase_DbDestroySyncGroup_ResponseParams struct { |
| outErr Error |
| } |
| |
| func (s *syncbase_DbDestroySyncGroup_ResponseParams) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(8, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.outErr.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_DbDestroySyncGroup_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{16, 0}, |
| } |
| |
| func (s *syncbase_DbDestroySyncGroup_ResponseParams) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_DbDestroySyncGroup_ResponseParams_Versions), func(i int) bool { |
| return syncbase_DbDestroySyncGroup_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_DbDestroySyncGroup_ResponseParams_Versions) { |
| if syncbase_DbDestroySyncGroup_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_DbDestroySyncGroup_ResponseParams_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.outErr.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (p *Syncbase_Proxy) DbDestroySyncGroup(inName string, inSgName string) (outErr Error, err error) { |
| payload := &syncbase_DbDestroySyncGroup_Params{ |
| inName, |
| inSgName, |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_DbDestroySyncGroup_Name, |
| Flags: bindings.MessageExpectsResponseFlag, |
| RequestId: p.ids.Count(), |
| } |
| var message *bindings.Message |
| if message, err = bindings.EncodeMessage(header, payload); err != nil { |
| err = fmt.Errorf("can't encode request: %v", err.Error()) |
| p.Close_Proxy() |
| return |
| } |
| readResult := <-p.router.AcceptWithResponse(message) |
| if err = readResult.Error; err != nil { |
| p.Close_Proxy() |
| return |
| } |
| if readResult.Message.Header.Flags != bindings.MessageIsResponseFlag { |
| err = &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", readResult.Message.Header.Flags), |
| } |
| return |
| } |
| if got, want := readResult.Message.Header.Type, syncbase_DbDestroySyncGroup_Name; got != want { |
| err = &bindings.ValidationError{bindings.MessageHeaderUnknownMethod, |
| fmt.Sprintf("invalid method in response: expected %v, got %v", want, got), |
| } |
| return |
| } |
| var response syncbase_DbDestroySyncGroup_ResponseParams |
| if err = readResult.Message.DecodePayload(&response); err != nil { |
| p.Close_Proxy() |
| return |
| } |
| outErr = response.outErr |
| return |
| } |
| |
| type syncbase_DbEjectFromSyncGroup_Params struct { |
| inName string |
| inSgName string |
| inMember string |
| } |
| |
| func (s *syncbase_DbEjectFromSyncGroup_Params) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(24, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.inName); err != nil { |
| return err |
| } |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.inSgName); err != nil { |
| return err |
| } |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.inMember); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_DbEjectFromSyncGroup_Params_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{32, 0}, |
| } |
| |
| func (s *syncbase_DbEjectFromSyncGroup_Params) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_DbEjectFromSyncGroup_Params_Versions), func(i int) bool { |
| return syncbase_DbEjectFromSyncGroup_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_DbEjectFromSyncGroup_Params_Versions) { |
| if syncbase_DbEjectFromSyncGroup_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_DbEjectFromSyncGroup_Params_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.inName = value0 |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.inSgName = value0 |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.inMember = value0 |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| type syncbase_DbEjectFromSyncGroup_ResponseParams struct { |
| outErr Error |
| } |
| |
| func (s *syncbase_DbEjectFromSyncGroup_ResponseParams) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(8, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.outErr.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_DbEjectFromSyncGroup_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{16, 0}, |
| } |
| |
| func (s *syncbase_DbEjectFromSyncGroup_ResponseParams) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_DbEjectFromSyncGroup_ResponseParams_Versions), func(i int) bool { |
| return syncbase_DbEjectFromSyncGroup_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_DbEjectFromSyncGroup_ResponseParams_Versions) { |
| if syncbase_DbEjectFromSyncGroup_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_DbEjectFromSyncGroup_ResponseParams_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.outErr.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (p *Syncbase_Proxy) DbEjectFromSyncGroup(inName string, inSgName string, inMember string) (outErr Error, err error) { |
| payload := &syncbase_DbEjectFromSyncGroup_Params{ |
| inName, |
| inSgName, |
| inMember, |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_DbEjectFromSyncGroup_Name, |
| Flags: bindings.MessageExpectsResponseFlag, |
| RequestId: p.ids.Count(), |
| } |
| var message *bindings.Message |
| if message, err = bindings.EncodeMessage(header, payload); err != nil { |
| err = fmt.Errorf("can't encode request: %v", err.Error()) |
| p.Close_Proxy() |
| return |
| } |
| readResult := <-p.router.AcceptWithResponse(message) |
| if err = readResult.Error; err != nil { |
| p.Close_Proxy() |
| return |
| } |
| if readResult.Message.Header.Flags != bindings.MessageIsResponseFlag { |
| err = &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", readResult.Message.Header.Flags), |
| } |
| return |
| } |
| if got, want := readResult.Message.Header.Type, syncbase_DbEjectFromSyncGroup_Name; got != want { |
| err = &bindings.ValidationError{bindings.MessageHeaderUnknownMethod, |
| fmt.Sprintf("invalid method in response: expected %v, got %v", want, got), |
| } |
| return |
| } |
| var response syncbase_DbEjectFromSyncGroup_ResponseParams |
| if err = readResult.Message.DecodePayload(&response); err != nil { |
| p.Close_Proxy() |
| return |
| } |
| outErr = response.outErr |
| return |
| } |
| |
| type syncbase_DbGetSyncGroupSpec_Params struct { |
| inName string |
| inSgName string |
| } |
| |
| func (s *syncbase_DbGetSyncGroupSpec_Params) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(16, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.inName); err != nil { |
| return err |
| } |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.inSgName); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_DbGetSyncGroupSpec_Params_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{24, 0}, |
| } |
| |
| func (s *syncbase_DbGetSyncGroupSpec_Params) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_DbGetSyncGroupSpec_Params_Versions), func(i int) bool { |
| return syncbase_DbGetSyncGroupSpec_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_DbGetSyncGroupSpec_Params_Versions) { |
| if syncbase_DbGetSyncGroupSpec_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_DbGetSyncGroupSpec_Params_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.inName = value0 |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.inSgName = value0 |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| type syncbase_DbGetSyncGroupSpec_ResponseParams struct { |
| outErr Error |
| outSpec SyncGroupSpec |
| outVersion string |
| } |
| |
| func (s *syncbase_DbGetSyncGroupSpec_ResponseParams) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(24, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.outErr.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.outSpec.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.outVersion); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_DbGetSyncGroupSpec_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{32, 0}, |
| } |
| |
| func (s *syncbase_DbGetSyncGroupSpec_ResponseParams) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_DbGetSyncGroupSpec_ResponseParams_Versions), func(i int) bool { |
| return syncbase_DbGetSyncGroupSpec_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_DbGetSyncGroupSpec_ResponseParams_Versions) { |
| if syncbase_DbGetSyncGroupSpec_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_DbGetSyncGroupSpec_ResponseParams_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.outErr.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.outSpec.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.outVersion = value0 |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (p *Syncbase_Proxy) DbGetSyncGroupSpec(inName string, inSgName string) (outErr Error, outSpec SyncGroupSpec, outVersion string, err error) { |
| payload := &syncbase_DbGetSyncGroupSpec_Params{ |
| inName, |
| inSgName, |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_DbGetSyncGroupSpec_Name, |
| Flags: bindings.MessageExpectsResponseFlag, |
| RequestId: p.ids.Count(), |
| } |
| var message *bindings.Message |
| if message, err = bindings.EncodeMessage(header, payload); err != nil { |
| err = fmt.Errorf("can't encode request: %v", err.Error()) |
| p.Close_Proxy() |
| return |
| } |
| readResult := <-p.router.AcceptWithResponse(message) |
| if err = readResult.Error; err != nil { |
| p.Close_Proxy() |
| return |
| } |
| if readResult.Message.Header.Flags != bindings.MessageIsResponseFlag { |
| err = &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", readResult.Message.Header.Flags), |
| } |
| return |
| } |
| if got, want := readResult.Message.Header.Type, syncbase_DbGetSyncGroupSpec_Name; got != want { |
| err = &bindings.ValidationError{bindings.MessageHeaderUnknownMethod, |
| fmt.Sprintf("invalid method in response: expected %v, got %v", want, got), |
| } |
| return |
| } |
| var response syncbase_DbGetSyncGroupSpec_ResponseParams |
| if err = readResult.Message.DecodePayload(&response); err != nil { |
| p.Close_Proxy() |
| return |
| } |
| outErr = response.outErr |
| outSpec = response.outSpec |
| outVersion = response.outVersion |
| return |
| } |
| |
| type syncbase_DbSetSyncGroupSpec_Params struct { |
| inName string |
| inSgName string |
| inSpec SyncGroupSpec |
| inVersion string |
| } |
| |
| func (s *syncbase_DbSetSyncGroupSpec_Params) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(32, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.inName); err != nil { |
| return err |
| } |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.inSgName); err != nil { |
| return err |
| } |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.inSpec.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.inVersion); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_DbSetSyncGroupSpec_Params_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{40, 0}, |
| } |
| |
| func (s *syncbase_DbSetSyncGroupSpec_Params) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_DbSetSyncGroupSpec_Params_Versions), func(i int) bool { |
| return syncbase_DbSetSyncGroupSpec_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_DbSetSyncGroupSpec_Params_Versions) { |
| if syncbase_DbSetSyncGroupSpec_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_DbSetSyncGroupSpec_Params_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.inName = value0 |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.inSgName = value0 |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.inSpec.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.inVersion = value0 |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| type syncbase_DbSetSyncGroupSpec_ResponseParams struct { |
| outErr Error |
| } |
| |
| func (s *syncbase_DbSetSyncGroupSpec_ResponseParams) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(8, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.outErr.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_DbSetSyncGroupSpec_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{16, 0}, |
| } |
| |
| func (s *syncbase_DbSetSyncGroupSpec_ResponseParams) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_DbSetSyncGroupSpec_ResponseParams_Versions), func(i int) bool { |
| return syncbase_DbSetSyncGroupSpec_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_DbSetSyncGroupSpec_ResponseParams_Versions) { |
| if syncbase_DbSetSyncGroupSpec_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_DbSetSyncGroupSpec_ResponseParams_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.outErr.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (p *Syncbase_Proxy) DbSetSyncGroupSpec(inName string, inSgName string, inSpec SyncGroupSpec, inVersion string) (outErr Error, err error) { |
| payload := &syncbase_DbSetSyncGroupSpec_Params{ |
| inName, |
| inSgName, |
| inSpec, |
| inVersion, |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_DbSetSyncGroupSpec_Name, |
| Flags: bindings.MessageExpectsResponseFlag, |
| RequestId: p.ids.Count(), |
| } |
| var message *bindings.Message |
| if message, err = bindings.EncodeMessage(header, payload); err != nil { |
| err = fmt.Errorf("can't encode request: %v", err.Error()) |
| p.Close_Proxy() |
| return |
| } |
| readResult := <-p.router.AcceptWithResponse(message) |
| if err = readResult.Error; err != nil { |
| p.Close_Proxy() |
| return |
| } |
| if readResult.Message.Header.Flags != bindings.MessageIsResponseFlag { |
| err = &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", readResult.Message.Header.Flags), |
| } |
| return |
| } |
| if got, want := readResult.Message.Header.Type, syncbase_DbSetSyncGroupSpec_Name; got != want { |
| err = &bindings.ValidationError{bindings.MessageHeaderUnknownMethod, |
| fmt.Sprintf("invalid method in response: expected %v, got %v", want, got), |
| } |
| return |
| } |
| var response syncbase_DbSetSyncGroupSpec_ResponseParams |
| if err = readResult.Message.DecodePayload(&response); err != nil { |
| p.Close_Proxy() |
| return |
| } |
| outErr = response.outErr |
| return |
| } |
| |
| type syncbase_DbGetSyncGroupMembers_Params struct { |
| inName string |
| inSgName string |
| } |
| |
| func (s *syncbase_DbGetSyncGroupMembers_Params) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(16, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.inName); err != nil { |
| return err |
| } |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.inSgName); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_DbGetSyncGroupMembers_Params_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{24, 0}, |
| } |
| |
| func (s *syncbase_DbGetSyncGroupMembers_Params) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_DbGetSyncGroupMembers_Params_Versions), func(i int) bool { |
| return syncbase_DbGetSyncGroupMembers_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_DbGetSyncGroupMembers_Params_Versions) { |
| if syncbase_DbGetSyncGroupMembers_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_DbGetSyncGroupMembers_Params_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.inName = value0 |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.inSgName = value0 |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| type syncbase_DbGetSyncGroupMembers_ResponseParams struct { |
| outErr Error |
| outInfos map[string]SyncGroupMemberInfo |
| } |
| |
| func (s *syncbase_DbGetSyncGroupMembers_ResponseParams) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(16, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.outErr.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| encoder.StartMap() |
| { |
| var keys0 []string |
| var values0 []SyncGroupMemberInfo |
| for key0, value0 := range s.outInfos { |
| keys0 = append(keys0, key0) |
| values0 = append(values0, value0) |
| } |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| encoder.StartArray(uint32(len(keys0)), 64) |
| for _, elem1 := range keys0 { |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(elem1); err != nil { |
| return err |
| } |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| encoder.StartArray(uint32(len(values0)), 64) |
| for _, elem1 := range values0 { |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := elem1.Encode(encoder); err != nil { |
| return err |
| } |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_DbGetSyncGroupMembers_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{24, 0}, |
| } |
| |
| func (s *syncbase_DbGetSyncGroupMembers_ResponseParams) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_DbGetSyncGroupMembers_ResponseParams_Versions), func(i int) bool { |
| return syncbase_DbGetSyncGroupMembers_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_DbGetSyncGroupMembers_ResponseParams_Versions) { |
| if syncbase_DbGetSyncGroupMembers_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_DbGetSyncGroupMembers_ResponseParams_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.outErr.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := decoder.StartMap(); err != nil { |
| return err |
| } |
| var keys0 []string |
| { |
| pointer1, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer1 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| len1, err := decoder.StartArray(64) |
| if err != nil { |
| return err |
| } |
| keys0 = make([]string, len1) |
| for i1 := uint32(0); i1 < len1; i1++ { |
| pointer2, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer2 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value2, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| keys0[i1] = value2 |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| } |
| } |
| var values0 []SyncGroupMemberInfo |
| { |
| pointer1, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer1 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| len1, err := decoder.StartArray(64) |
| if err != nil { |
| return err |
| } |
| values0 = make([]SyncGroupMemberInfo, len1) |
| for i1 := uint32(0); i1 < len1; i1++ { |
| pointer2, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer2 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := values0[i1].Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| } |
| } |
| if len(keys0) != len(values0) { |
| return &bindings.ValidationError{bindings.DifferentSizedArraysInMap, |
| fmt.Sprintf("Number of keys %d is different from number of values %d", len(keys0), len(values0)), |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| len0 := len(keys0) |
| map0 := make(map[string]SyncGroupMemberInfo) |
| for i0 := 0; i0 < len0; i0++ { |
| map0[keys0[i0]] = values0[i0] |
| } |
| s.outInfos = map0 |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (p *Syncbase_Proxy) DbGetSyncGroupMembers(inName string, inSgName string) (outErr Error, outInfos map[string]SyncGroupMemberInfo, err error) { |
| payload := &syncbase_DbGetSyncGroupMembers_Params{ |
| inName, |
| inSgName, |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_DbGetSyncGroupMembers_Name, |
| Flags: bindings.MessageExpectsResponseFlag, |
| RequestId: p.ids.Count(), |
| } |
| var message *bindings.Message |
| if message, err = bindings.EncodeMessage(header, payload); err != nil { |
| err = fmt.Errorf("can't encode request: %v", err.Error()) |
| p.Close_Proxy() |
| return |
| } |
| readResult := <-p.router.AcceptWithResponse(message) |
| if err = readResult.Error; err != nil { |
| p.Close_Proxy() |
| return |
| } |
| if readResult.Message.Header.Flags != bindings.MessageIsResponseFlag { |
| err = &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", readResult.Message.Header.Flags), |
| } |
| return |
| } |
| if got, want := readResult.Message.Header.Type, syncbase_DbGetSyncGroupMembers_Name; got != want { |
| err = &bindings.ValidationError{bindings.MessageHeaderUnknownMethod, |
| fmt.Sprintf("invalid method in response: expected %v, got %v", want, got), |
| } |
| return |
| } |
| var response syncbase_DbGetSyncGroupMembers_ResponseParams |
| if err = readResult.Message.DecodePayload(&response); err != nil { |
| p.Close_Proxy() |
| return |
| } |
| outErr = response.outErr |
| outInfos = response.outInfos |
| return |
| } |
| |
| type syncbase_TableCreate_Params struct { |
| inName string |
| inPerms Perms |
| } |
| |
| func (s *syncbase_TableCreate_Params) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(16, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.inName); err != nil { |
| return err |
| } |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.inPerms.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_TableCreate_Params_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{24, 0}, |
| } |
| |
| func (s *syncbase_TableCreate_Params) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_TableCreate_Params_Versions), func(i int) bool { |
| return syncbase_TableCreate_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_TableCreate_Params_Versions) { |
| if syncbase_TableCreate_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_TableCreate_Params_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.inName = value0 |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.inPerms.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| type syncbase_TableCreate_ResponseParams struct { |
| outErr Error |
| } |
| |
| func (s *syncbase_TableCreate_ResponseParams) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(8, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.outErr.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_TableCreate_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{16, 0}, |
| } |
| |
| func (s *syncbase_TableCreate_ResponseParams) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_TableCreate_ResponseParams_Versions), func(i int) bool { |
| return syncbase_TableCreate_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_TableCreate_ResponseParams_Versions) { |
| if syncbase_TableCreate_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_TableCreate_ResponseParams_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.outErr.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (p *Syncbase_Proxy) TableCreate(inName string, inPerms Perms) (outErr Error, err error) { |
| payload := &syncbase_TableCreate_Params{ |
| inName, |
| inPerms, |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_TableCreate_Name, |
| Flags: bindings.MessageExpectsResponseFlag, |
| RequestId: p.ids.Count(), |
| } |
| var message *bindings.Message |
| if message, err = bindings.EncodeMessage(header, payload); err != nil { |
| err = fmt.Errorf("can't encode request: %v", err.Error()) |
| p.Close_Proxy() |
| return |
| } |
| readResult := <-p.router.AcceptWithResponse(message) |
| if err = readResult.Error; err != nil { |
| p.Close_Proxy() |
| return |
| } |
| if readResult.Message.Header.Flags != bindings.MessageIsResponseFlag { |
| err = &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", readResult.Message.Header.Flags), |
| } |
| return |
| } |
| if got, want := readResult.Message.Header.Type, syncbase_TableCreate_Name; got != want { |
| err = &bindings.ValidationError{bindings.MessageHeaderUnknownMethod, |
| fmt.Sprintf("invalid method in response: expected %v, got %v", want, got), |
| } |
| return |
| } |
| var response syncbase_TableCreate_ResponseParams |
| if err = readResult.Message.DecodePayload(&response); err != nil { |
| p.Close_Proxy() |
| return |
| } |
| outErr = response.outErr |
| return |
| } |
| |
| type syncbase_TableDelete_Params struct { |
| inName string |
| } |
| |
| func (s *syncbase_TableDelete_Params) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(8, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.inName); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_TableDelete_Params_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{16, 0}, |
| } |
| |
| func (s *syncbase_TableDelete_Params) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_TableDelete_Params_Versions), func(i int) bool { |
| return syncbase_TableDelete_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_TableDelete_Params_Versions) { |
| if syncbase_TableDelete_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_TableDelete_Params_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.inName = value0 |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| type syncbase_TableDelete_ResponseParams struct { |
| outErr Error |
| } |
| |
| func (s *syncbase_TableDelete_ResponseParams) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(8, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.outErr.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_TableDelete_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{16, 0}, |
| } |
| |
| func (s *syncbase_TableDelete_ResponseParams) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_TableDelete_ResponseParams_Versions), func(i int) bool { |
| return syncbase_TableDelete_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_TableDelete_ResponseParams_Versions) { |
| if syncbase_TableDelete_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_TableDelete_ResponseParams_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.outErr.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (p *Syncbase_Proxy) TableDelete(inName string) (outErr Error, err error) { |
| payload := &syncbase_TableDelete_Params{ |
| inName, |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_TableDelete_Name, |
| Flags: bindings.MessageExpectsResponseFlag, |
| RequestId: p.ids.Count(), |
| } |
| var message *bindings.Message |
| if message, err = bindings.EncodeMessage(header, payload); err != nil { |
| err = fmt.Errorf("can't encode request: %v", err.Error()) |
| p.Close_Proxy() |
| return |
| } |
| readResult := <-p.router.AcceptWithResponse(message) |
| if err = readResult.Error; err != nil { |
| p.Close_Proxy() |
| return |
| } |
| if readResult.Message.Header.Flags != bindings.MessageIsResponseFlag { |
| err = &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", readResult.Message.Header.Flags), |
| } |
| return |
| } |
| if got, want := readResult.Message.Header.Type, syncbase_TableDelete_Name; got != want { |
| err = &bindings.ValidationError{bindings.MessageHeaderUnknownMethod, |
| fmt.Sprintf("invalid method in response: expected %v, got %v", want, got), |
| } |
| return |
| } |
| var response syncbase_TableDelete_ResponseParams |
| if err = readResult.Message.DecodePayload(&response); err != nil { |
| p.Close_Proxy() |
| return |
| } |
| outErr = response.outErr |
| return |
| } |
| |
| type syncbase_TableExists_Params struct { |
| inName string |
| } |
| |
| func (s *syncbase_TableExists_Params) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(8, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.inName); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_TableExists_Params_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{16, 0}, |
| } |
| |
| func (s *syncbase_TableExists_Params) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_TableExists_Params_Versions), func(i int) bool { |
| return syncbase_TableExists_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_TableExists_Params_Versions) { |
| if syncbase_TableExists_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_TableExists_Params_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.inName = value0 |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| type syncbase_TableExists_ResponseParams struct { |
| outErr Error |
| outExists bool |
| } |
| |
| func (s *syncbase_TableExists_ResponseParams) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(16, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.outErr.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.WriteBool(s.outExists); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_TableExists_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{24, 0}, |
| } |
| |
| func (s *syncbase_TableExists_ResponseParams) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_TableExists_ResponseParams_Versions), func(i int) bool { |
| return syncbase_TableExists_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_TableExists_ResponseParams_Versions) { |
| if syncbase_TableExists_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_TableExists_ResponseParams_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.outErr.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| value0, err := decoder.ReadBool() |
| if err != nil { |
| return err |
| } |
| s.outExists = value0 |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (p *Syncbase_Proxy) TableExists(inName string) (outErr Error, outExists bool, err error) { |
| payload := &syncbase_TableExists_Params{ |
| inName, |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_TableExists_Name, |
| Flags: bindings.MessageExpectsResponseFlag, |
| RequestId: p.ids.Count(), |
| } |
| var message *bindings.Message |
| if message, err = bindings.EncodeMessage(header, payload); err != nil { |
| err = fmt.Errorf("can't encode request: %v", err.Error()) |
| p.Close_Proxy() |
| return |
| } |
| readResult := <-p.router.AcceptWithResponse(message) |
| if err = readResult.Error; err != nil { |
| p.Close_Proxy() |
| return |
| } |
| if readResult.Message.Header.Flags != bindings.MessageIsResponseFlag { |
| err = &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", readResult.Message.Header.Flags), |
| } |
| return |
| } |
| if got, want := readResult.Message.Header.Type, syncbase_TableExists_Name; got != want { |
| err = &bindings.ValidationError{bindings.MessageHeaderUnknownMethod, |
| fmt.Sprintf("invalid method in response: expected %v, got %v", want, got), |
| } |
| return |
| } |
| var response syncbase_TableExists_ResponseParams |
| if err = readResult.Message.DecodePayload(&response); err != nil { |
| p.Close_Proxy() |
| return |
| } |
| outErr = response.outErr |
| outExists = response.outExists |
| return |
| } |
| |
| type syncbase_TableDeleteRowRange_Params struct { |
| inName string |
| inStart []uint8 |
| inLimit []uint8 |
| } |
| |
| func (s *syncbase_TableDeleteRowRange_Params) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(24, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.inName); err != nil { |
| return err |
| } |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| encoder.StartArray(uint32(len(s.inStart)), 8) |
| for _, elem0 := range s.inStart { |
| if err := encoder.WriteUint8(elem0); err != nil { |
| return err |
| } |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| encoder.StartArray(uint32(len(s.inLimit)), 8) |
| for _, elem0 := range s.inLimit { |
| if err := encoder.WriteUint8(elem0); err != nil { |
| return err |
| } |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_TableDeleteRowRange_Params_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{32, 0}, |
| } |
| |
| func (s *syncbase_TableDeleteRowRange_Params) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_TableDeleteRowRange_Params_Versions), func(i int) bool { |
| return syncbase_TableDeleteRowRange_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_TableDeleteRowRange_Params_Versions) { |
| if syncbase_TableDeleteRowRange_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_TableDeleteRowRange_Params_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.inName = value0 |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| len0, err := decoder.StartArray(8) |
| if err != nil { |
| return err |
| } |
| s.inStart = make([]uint8, len0) |
| for i0 := uint32(0); i0 < len0; i0++ { |
| value1, err := decoder.ReadUint8() |
| if err != nil { |
| return err |
| } |
| s.inStart[i0] = value1 |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| len0, err := decoder.StartArray(8) |
| if err != nil { |
| return err |
| } |
| s.inLimit = make([]uint8, len0) |
| for i0 := uint32(0); i0 < len0; i0++ { |
| value1, err := decoder.ReadUint8() |
| if err != nil { |
| return err |
| } |
| s.inLimit[i0] = value1 |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| type syncbase_TableDeleteRowRange_ResponseParams struct { |
| outErr Error |
| } |
| |
| func (s *syncbase_TableDeleteRowRange_ResponseParams) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(8, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.outErr.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_TableDeleteRowRange_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{16, 0}, |
| } |
| |
| func (s *syncbase_TableDeleteRowRange_ResponseParams) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_TableDeleteRowRange_ResponseParams_Versions), func(i int) bool { |
| return syncbase_TableDeleteRowRange_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_TableDeleteRowRange_ResponseParams_Versions) { |
| if syncbase_TableDeleteRowRange_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_TableDeleteRowRange_ResponseParams_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.outErr.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (p *Syncbase_Proxy) TableDeleteRowRange(inName string, inStart []uint8, inLimit []uint8) (outErr Error, err error) { |
| payload := &syncbase_TableDeleteRowRange_Params{ |
| inName, |
| inStart, |
| inLimit, |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_TableDeleteRowRange_Name, |
| Flags: bindings.MessageExpectsResponseFlag, |
| RequestId: p.ids.Count(), |
| } |
| var message *bindings.Message |
| if message, err = bindings.EncodeMessage(header, payload); err != nil { |
| err = fmt.Errorf("can't encode request: %v", err.Error()) |
| p.Close_Proxy() |
| return |
| } |
| readResult := <-p.router.AcceptWithResponse(message) |
| if err = readResult.Error; err != nil { |
| p.Close_Proxy() |
| return |
| } |
| if readResult.Message.Header.Flags != bindings.MessageIsResponseFlag { |
| err = &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", readResult.Message.Header.Flags), |
| } |
| return |
| } |
| if got, want := readResult.Message.Header.Type, syncbase_TableDeleteRowRange_Name; got != want { |
| err = &bindings.ValidationError{bindings.MessageHeaderUnknownMethod, |
| fmt.Sprintf("invalid method in response: expected %v, got %v", want, got), |
| } |
| return |
| } |
| var response syncbase_TableDeleteRowRange_ResponseParams |
| if err = readResult.Message.DecodePayload(&response); err != nil { |
| p.Close_Proxy() |
| return |
| } |
| outErr = response.outErr |
| return |
| } |
| |
| type syncbase_TableScan_Params struct { |
| inName string |
| inStart []uint8 |
| inLimit []uint8 |
| } |
| |
| func (s *syncbase_TableScan_Params) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(24, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.inName); err != nil { |
| return err |
| } |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| encoder.StartArray(uint32(len(s.inStart)), 8) |
| for _, elem0 := range s.inStart { |
| if err := encoder.WriteUint8(elem0); err != nil { |
| return err |
| } |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| encoder.StartArray(uint32(len(s.inLimit)), 8) |
| for _, elem0 := range s.inLimit { |
| if err := encoder.WriteUint8(elem0); err != nil { |
| return err |
| } |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_TableScan_Params_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{32, 0}, |
| } |
| |
| func (s *syncbase_TableScan_Params) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_TableScan_Params_Versions), func(i int) bool { |
| return syncbase_TableScan_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_TableScan_Params_Versions) { |
| if syncbase_TableScan_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_TableScan_Params_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.inName = value0 |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| len0, err := decoder.StartArray(8) |
| if err != nil { |
| return err |
| } |
| s.inStart = make([]uint8, len0) |
| for i0 := uint32(0); i0 < len0; i0++ { |
| value1, err := decoder.ReadUint8() |
| if err != nil { |
| return err |
| } |
| s.inStart[i0] = value1 |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| len0, err := decoder.StartArray(8) |
| if err != nil { |
| return err |
| } |
| s.inLimit = make([]uint8, len0) |
| for i0 := uint32(0); i0 < len0; i0++ { |
| value1, err := decoder.ReadUint8() |
| if err != nil { |
| return err |
| } |
| s.inLimit[i0] = value1 |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| type syncbase_TableScan_ResponseParams struct { |
| outErr Error |
| } |
| |
| func (s *syncbase_TableScan_ResponseParams) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(8, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.outErr.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_TableScan_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{16, 0}, |
| } |
| |
| func (s *syncbase_TableScan_ResponseParams) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_TableScan_ResponseParams_Versions), func(i int) bool { |
| return syncbase_TableScan_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_TableScan_ResponseParams_Versions) { |
| if syncbase_TableScan_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_TableScan_ResponseParams_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.outErr.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (p *Syncbase_Proxy) TableScan(inName string, inStart []uint8, inLimit []uint8) (outErr Error, err error) { |
| payload := &syncbase_TableScan_Params{ |
| inName, |
| inStart, |
| inLimit, |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_TableScan_Name, |
| Flags: bindings.MessageExpectsResponseFlag, |
| RequestId: p.ids.Count(), |
| } |
| var message *bindings.Message |
| if message, err = bindings.EncodeMessage(header, payload); err != nil { |
| err = fmt.Errorf("can't encode request: %v", err.Error()) |
| p.Close_Proxy() |
| return |
| } |
| readResult := <-p.router.AcceptWithResponse(message) |
| if err = readResult.Error; err != nil { |
| p.Close_Proxy() |
| return |
| } |
| if readResult.Message.Header.Flags != bindings.MessageIsResponseFlag { |
| err = &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", readResult.Message.Header.Flags), |
| } |
| return |
| } |
| if got, want := readResult.Message.Header.Type, syncbase_TableScan_Name; got != want { |
| err = &bindings.ValidationError{bindings.MessageHeaderUnknownMethod, |
| fmt.Sprintf("invalid method in response: expected %v, got %v", want, got), |
| } |
| return |
| } |
| var response syncbase_TableScan_ResponseParams |
| if err = readResult.Message.DecodePayload(&response); err != nil { |
| p.Close_Proxy() |
| return |
| } |
| outErr = response.outErr |
| return |
| } |
| |
| type syncbase_TableGetPermissions_Params struct { |
| inName string |
| inKey string |
| } |
| |
| func (s *syncbase_TableGetPermissions_Params) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(16, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.inName); err != nil { |
| return err |
| } |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.inKey); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_TableGetPermissions_Params_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{24, 0}, |
| } |
| |
| func (s *syncbase_TableGetPermissions_Params) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_TableGetPermissions_Params_Versions), func(i int) bool { |
| return syncbase_TableGetPermissions_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_TableGetPermissions_Params_Versions) { |
| if syncbase_TableGetPermissions_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_TableGetPermissions_Params_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.inName = value0 |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.inKey = value0 |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| type syncbase_TableGetPermissions_ResponseParams struct { |
| outErr Error |
| outPermsArr []PrefixPerms |
| } |
| |
| func (s *syncbase_TableGetPermissions_ResponseParams) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(16, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.outErr.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| encoder.StartArray(uint32(len(s.outPermsArr)), 64) |
| for _, elem0 := range s.outPermsArr { |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := elem0.Encode(encoder); err != nil { |
| return err |
| } |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_TableGetPermissions_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{24, 0}, |
| } |
| |
| func (s *syncbase_TableGetPermissions_ResponseParams) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_TableGetPermissions_ResponseParams_Versions), func(i int) bool { |
| return syncbase_TableGetPermissions_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_TableGetPermissions_ResponseParams_Versions) { |
| if syncbase_TableGetPermissions_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_TableGetPermissions_ResponseParams_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.outErr.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| len0, err := decoder.StartArray(64) |
| if err != nil { |
| return err |
| } |
| s.outPermsArr = make([]PrefixPerms, len0) |
| for i0 := uint32(0); i0 < len0; i0++ { |
| pointer1, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer1 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.outPermsArr[i0].Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (p *Syncbase_Proxy) TableGetPermissions(inName string, inKey string) (outErr Error, outPermsArr []PrefixPerms, err error) { |
| payload := &syncbase_TableGetPermissions_Params{ |
| inName, |
| inKey, |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_TableGetPermissions_Name, |
| Flags: bindings.MessageExpectsResponseFlag, |
| RequestId: p.ids.Count(), |
| } |
| var message *bindings.Message |
| if message, err = bindings.EncodeMessage(header, payload); err != nil { |
| err = fmt.Errorf("can't encode request: %v", err.Error()) |
| p.Close_Proxy() |
| return |
| } |
| readResult := <-p.router.AcceptWithResponse(message) |
| if err = readResult.Error; err != nil { |
| p.Close_Proxy() |
| return |
| } |
| if readResult.Message.Header.Flags != bindings.MessageIsResponseFlag { |
| err = &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", readResult.Message.Header.Flags), |
| } |
| return |
| } |
| if got, want := readResult.Message.Header.Type, syncbase_TableGetPermissions_Name; got != want { |
| err = &bindings.ValidationError{bindings.MessageHeaderUnknownMethod, |
| fmt.Sprintf("invalid method in response: expected %v, got %v", want, got), |
| } |
| return |
| } |
| var response syncbase_TableGetPermissions_ResponseParams |
| if err = readResult.Message.DecodePayload(&response); err != nil { |
| p.Close_Proxy() |
| return |
| } |
| outErr = response.outErr |
| outPermsArr = response.outPermsArr |
| return |
| } |
| |
| type syncbase_TableSetPermissions_Params struct { |
| inName string |
| inPrefix string |
| inPerms Perms |
| } |
| |
| func (s *syncbase_TableSetPermissions_Params) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(24, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.inName); err != nil { |
| return err |
| } |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.inPrefix); err != nil { |
| return err |
| } |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.inPerms.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_TableSetPermissions_Params_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{32, 0}, |
| } |
| |
| func (s *syncbase_TableSetPermissions_Params) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_TableSetPermissions_Params_Versions), func(i int) bool { |
| return syncbase_TableSetPermissions_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_TableSetPermissions_Params_Versions) { |
| if syncbase_TableSetPermissions_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_TableSetPermissions_Params_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.inName = value0 |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.inPrefix = value0 |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.inPerms.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| type syncbase_TableSetPermissions_ResponseParams struct { |
| outErr Error |
| } |
| |
| func (s *syncbase_TableSetPermissions_ResponseParams) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(8, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.outErr.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_TableSetPermissions_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{16, 0}, |
| } |
| |
| func (s *syncbase_TableSetPermissions_ResponseParams) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_TableSetPermissions_ResponseParams_Versions), func(i int) bool { |
| return syncbase_TableSetPermissions_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_TableSetPermissions_ResponseParams_Versions) { |
| if syncbase_TableSetPermissions_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_TableSetPermissions_ResponseParams_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.outErr.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (p *Syncbase_Proxy) TableSetPermissions(inName string, inPrefix string, inPerms Perms) (outErr Error, err error) { |
| payload := &syncbase_TableSetPermissions_Params{ |
| inName, |
| inPrefix, |
| inPerms, |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_TableSetPermissions_Name, |
| Flags: bindings.MessageExpectsResponseFlag, |
| RequestId: p.ids.Count(), |
| } |
| var message *bindings.Message |
| if message, err = bindings.EncodeMessage(header, payload); err != nil { |
| err = fmt.Errorf("can't encode request: %v", err.Error()) |
| p.Close_Proxy() |
| return |
| } |
| readResult := <-p.router.AcceptWithResponse(message) |
| if err = readResult.Error; err != nil { |
| p.Close_Proxy() |
| return |
| } |
| if readResult.Message.Header.Flags != bindings.MessageIsResponseFlag { |
| err = &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", readResult.Message.Header.Flags), |
| } |
| return |
| } |
| if got, want := readResult.Message.Header.Type, syncbase_TableSetPermissions_Name; got != want { |
| err = &bindings.ValidationError{bindings.MessageHeaderUnknownMethod, |
| fmt.Sprintf("invalid method in response: expected %v, got %v", want, got), |
| } |
| return |
| } |
| var response syncbase_TableSetPermissions_ResponseParams |
| if err = readResult.Message.DecodePayload(&response); err != nil { |
| p.Close_Proxy() |
| return |
| } |
| outErr = response.outErr |
| return |
| } |
| |
| type syncbase_TableDeletePermissions_Params struct { |
| inName string |
| inPrefix string |
| } |
| |
| func (s *syncbase_TableDeletePermissions_Params) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(16, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.inName); err != nil { |
| return err |
| } |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.inPrefix); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_TableDeletePermissions_Params_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{24, 0}, |
| } |
| |
| func (s *syncbase_TableDeletePermissions_Params) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_TableDeletePermissions_Params_Versions), func(i int) bool { |
| return syncbase_TableDeletePermissions_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_TableDeletePermissions_Params_Versions) { |
| if syncbase_TableDeletePermissions_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_TableDeletePermissions_Params_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.inName = value0 |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.inPrefix = value0 |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| type syncbase_TableDeletePermissions_ResponseParams struct { |
| outErr Error |
| } |
| |
| func (s *syncbase_TableDeletePermissions_ResponseParams) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(8, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.outErr.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_TableDeletePermissions_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{16, 0}, |
| } |
| |
| func (s *syncbase_TableDeletePermissions_ResponseParams) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_TableDeletePermissions_ResponseParams_Versions), func(i int) bool { |
| return syncbase_TableDeletePermissions_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_TableDeletePermissions_ResponseParams_Versions) { |
| if syncbase_TableDeletePermissions_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_TableDeletePermissions_ResponseParams_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.outErr.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (p *Syncbase_Proxy) TableDeletePermissions(inName string, inPrefix string) (outErr Error, err error) { |
| payload := &syncbase_TableDeletePermissions_Params{ |
| inName, |
| inPrefix, |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_TableDeletePermissions_Name, |
| Flags: bindings.MessageExpectsResponseFlag, |
| RequestId: p.ids.Count(), |
| } |
| var message *bindings.Message |
| if message, err = bindings.EncodeMessage(header, payload); err != nil { |
| err = fmt.Errorf("can't encode request: %v", err.Error()) |
| p.Close_Proxy() |
| return |
| } |
| readResult := <-p.router.AcceptWithResponse(message) |
| if err = readResult.Error; err != nil { |
| p.Close_Proxy() |
| return |
| } |
| if readResult.Message.Header.Flags != bindings.MessageIsResponseFlag { |
| err = &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", readResult.Message.Header.Flags), |
| } |
| return |
| } |
| if got, want := readResult.Message.Header.Type, syncbase_TableDeletePermissions_Name; got != want { |
| err = &bindings.ValidationError{bindings.MessageHeaderUnknownMethod, |
| fmt.Sprintf("invalid method in response: expected %v, got %v", want, got), |
| } |
| return |
| } |
| var response syncbase_TableDeletePermissions_ResponseParams |
| if err = readResult.Message.DecodePayload(&response); err != nil { |
| p.Close_Proxy() |
| return |
| } |
| outErr = response.outErr |
| return |
| } |
| |
| type syncbase_RowExists_Params struct { |
| inName string |
| } |
| |
| func (s *syncbase_RowExists_Params) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(8, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.inName); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_RowExists_Params_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{16, 0}, |
| } |
| |
| func (s *syncbase_RowExists_Params) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_RowExists_Params_Versions), func(i int) bool { |
| return syncbase_RowExists_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_RowExists_Params_Versions) { |
| if syncbase_RowExists_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_RowExists_Params_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.inName = value0 |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| type syncbase_RowExists_ResponseParams struct { |
| outErr Error |
| outExists bool |
| } |
| |
| func (s *syncbase_RowExists_ResponseParams) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(16, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.outErr.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.WriteBool(s.outExists); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_RowExists_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{24, 0}, |
| } |
| |
| func (s *syncbase_RowExists_ResponseParams) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_RowExists_ResponseParams_Versions), func(i int) bool { |
| return syncbase_RowExists_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_RowExists_ResponseParams_Versions) { |
| if syncbase_RowExists_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_RowExists_ResponseParams_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.outErr.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| value0, err := decoder.ReadBool() |
| if err != nil { |
| return err |
| } |
| s.outExists = value0 |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (p *Syncbase_Proxy) RowExists(inName string) (outErr Error, outExists bool, err error) { |
| payload := &syncbase_RowExists_Params{ |
| inName, |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_RowExists_Name, |
| Flags: bindings.MessageExpectsResponseFlag, |
| RequestId: p.ids.Count(), |
| } |
| var message *bindings.Message |
| if message, err = bindings.EncodeMessage(header, payload); err != nil { |
| err = fmt.Errorf("can't encode request: %v", err.Error()) |
| p.Close_Proxy() |
| return |
| } |
| readResult := <-p.router.AcceptWithResponse(message) |
| if err = readResult.Error; err != nil { |
| p.Close_Proxy() |
| return |
| } |
| if readResult.Message.Header.Flags != bindings.MessageIsResponseFlag { |
| err = &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", readResult.Message.Header.Flags), |
| } |
| return |
| } |
| if got, want := readResult.Message.Header.Type, syncbase_RowExists_Name; got != want { |
| err = &bindings.ValidationError{bindings.MessageHeaderUnknownMethod, |
| fmt.Sprintf("invalid method in response: expected %v, got %v", want, got), |
| } |
| return |
| } |
| var response syncbase_RowExists_ResponseParams |
| if err = readResult.Message.DecodePayload(&response); err != nil { |
| p.Close_Proxy() |
| return |
| } |
| outErr = response.outErr |
| outExists = response.outExists |
| return |
| } |
| |
| type syncbase_RowGet_Params struct { |
| inName string |
| } |
| |
| func (s *syncbase_RowGet_Params) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(8, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.inName); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_RowGet_Params_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{16, 0}, |
| } |
| |
| func (s *syncbase_RowGet_Params) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_RowGet_Params_Versions), func(i int) bool { |
| return syncbase_RowGet_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_RowGet_Params_Versions) { |
| if syncbase_RowGet_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_RowGet_Params_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.inName = value0 |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| type syncbase_RowGet_ResponseParams struct { |
| outErr Error |
| outValue []uint8 |
| } |
| |
| func (s *syncbase_RowGet_ResponseParams) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(16, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.outErr.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| encoder.StartArray(uint32(len(s.outValue)), 8) |
| for _, elem0 := range s.outValue { |
| if err := encoder.WriteUint8(elem0); err != nil { |
| return err |
| } |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_RowGet_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{24, 0}, |
| } |
| |
| func (s *syncbase_RowGet_ResponseParams) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_RowGet_ResponseParams_Versions), func(i int) bool { |
| return syncbase_RowGet_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_RowGet_ResponseParams_Versions) { |
| if syncbase_RowGet_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_RowGet_ResponseParams_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.outErr.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| len0, err := decoder.StartArray(8) |
| if err != nil { |
| return err |
| } |
| s.outValue = make([]uint8, len0) |
| for i0 := uint32(0); i0 < len0; i0++ { |
| value1, err := decoder.ReadUint8() |
| if err != nil { |
| return err |
| } |
| s.outValue[i0] = value1 |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (p *Syncbase_Proxy) RowGet(inName string) (outErr Error, outValue []uint8, err error) { |
| payload := &syncbase_RowGet_Params{ |
| inName, |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_RowGet_Name, |
| Flags: bindings.MessageExpectsResponseFlag, |
| RequestId: p.ids.Count(), |
| } |
| var message *bindings.Message |
| if message, err = bindings.EncodeMessage(header, payload); err != nil { |
| err = fmt.Errorf("can't encode request: %v", err.Error()) |
| p.Close_Proxy() |
| return |
| } |
| readResult := <-p.router.AcceptWithResponse(message) |
| if err = readResult.Error; err != nil { |
| p.Close_Proxy() |
| return |
| } |
| if readResult.Message.Header.Flags != bindings.MessageIsResponseFlag { |
| err = &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", readResult.Message.Header.Flags), |
| } |
| return |
| } |
| if got, want := readResult.Message.Header.Type, syncbase_RowGet_Name; got != want { |
| err = &bindings.ValidationError{bindings.MessageHeaderUnknownMethod, |
| fmt.Sprintf("invalid method in response: expected %v, got %v", want, got), |
| } |
| return |
| } |
| var response syncbase_RowGet_ResponseParams |
| if err = readResult.Message.DecodePayload(&response); err != nil { |
| p.Close_Proxy() |
| return |
| } |
| outErr = response.outErr |
| outValue = response.outValue |
| return |
| } |
| |
| type syncbase_RowPut_Params struct { |
| inName string |
| inValue []uint8 |
| } |
| |
| func (s *syncbase_RowPut_Params) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(16, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.inName); err != nil { |
| return err |
| } |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| encoder.StartArray(uint32(len(s.inValue)), 8) |
| for _, elem0 := range s.inValue { |
| if err := encoder.WriteUint8(elem0); err != nil { |
| return err |
| } |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_RowPut_Params_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{24, 0}, |
| } |
| |
| func (s *syncbase_RowPut_Params) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_RowPut_Params_Versions), func(i int) bool { |
| return syncbase_RowPut_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_RowPut_Params_Versions) { |
| if syncbase_RowPut_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_RowPut_Params_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.inName = value0 |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| len0, err := decoder.StartArray(8) |
| if err != nil { |
| return err |
| } |
| s.inValue = make([]uint8, len0) |
| for i0 := uint32(0); i0 < len0; i0++ { |
| value1, err := decoder.ReadUint8() |
| if err != nil { |
| return err |
| } |
| s.inValue[i0] = value1 |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| type syncbase_RowPut_ResponseParams struct { |
| outErr Error |
| } |
| |
| func (s *syncbase_RowPut_ResponseParams) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(8, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.outErr.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_RowPut_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{16, 0}, |
| } |
| |
| func (s *syncbase_RowPut_ResponseParams) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_RowPut_ResponseParams_Versions), func(i int) bool { |
| return syncbase_RowPut_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_RowPut_ResponseParams_Versions) { |
| if syncbase_RowPut_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_RowPut_ResponseParams_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.outErr.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (p *Syncbase_Proxy) RowPut(inName string, inValue []uint8) (outErr Error, err error) { |
| payload := &syncbase_RowPut_Params{ |
| inName, |
| inValue, |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_RowPut_Name, |
| Flags: bindings.MessageExpectsResponseFlag, |
| RequestId: p.ids.Count(), |
| } |
| var message *bindings.Message |
| if message, err = bindings.EncodeMessage(header, payload); err != nil { |
| err = fmt.Errorf("can't encode request: %v", err.Error()) |
| p.Close_Proxy() |
| return |
| } |
| readResult := <-p.router.AcceptWithResponse(message) |
| if err = readResult.Error; err != nil { |
| p.Close_Proxy() |
| return |
| } |
| if readResult.Message.Header.Flags != bindings.MessageIsResponseFlag { |
| err = &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", readResult.Message.Header.Flags), |
| } |
| return |
| } |
| if got, want := readResult.Message.Header.Type, syncbase_RowPut_Name; got != want { |
| err = &bindings.ValidationError{bindings.MessageHeaderUnknownMethod, |
| fmt.Sprintf("invalid method in response: expected %v, got %v", want, got), |
| } |
| return |
| } |
| var response syncbase_RowPut_ResponseParams |
| if err = readResult.Message.DecodePayload(&response); err != nil { |
| p.Close_Proxy() |
| return |
| } |
| outErr = response.outErr |
| return |
| } |
| |
| type syncbase_RowDelete_Params struct { |
| inName string |
| } |
| |
| func (s *syncbase_RowDelete_Params) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(8, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.inName); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_RowDelete_Params_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{16, 0}, |
| } |
| |
| func (s *syncbase_RowDelete_Params) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_RowDelete_Params_Versions), func(i int) bool { |
| return syncbase_RowDelete_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_RowDelete_Params_Versions) { |
| if syncbase_RowDelete_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_RowDelete_Params_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.inName = value0 |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| type syncbase_RowDelete_ResponseParams struct { |
| outErr Error |
| } |
| |
| func (s *syncbase_RowDelete_ResponseParams) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(8, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.outErr.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncbase_RowDelete_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{16, 0}, |
| } |
| |
| func (s *syncbase_RowDelete_ResponseParams) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncbase_RowDelete_ResponseParams_Versions), func(i int) bool { |
| return syncbase_RowDelete_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncbase_RowDelete_ResponseParams_Versions) { |
| if syncbase_RowDelete_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncbase_RowDelete_ResponseParams_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.outErr.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| func (p *Syncbase_Proxy) RowDelete(inName string) (outErr Error, err error) { |
| payload := &syncbase_RowDelete_Params{ |
| inName, |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_RowDelete_Name, |
| Flags: bindings.MessageExpectsResponseFlag, |
| RequestId: p.ids.Count(), |
| } |
| var message *bindings.Message |
| if message, err = bindings.EncodeMessage(header, payload); err != nil { |
| err = fmt.Errorf("can't encode request: %v", err.Error()) |
| p.Close_Proxy() |
| return |
| } |
| readResult := <-p.router.AcceptWithResponse(message) |
| if err = readResult.Error; err != nil { |
| p.Close_Proxy() |
| return |
| } |
| if readResult.Message.Header.Flags != bindings.MessageIsResponseFlag { |
| err = &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", readResult.Message.Header.Flags), |
| } |
| return |
| } |
| if got, want := readResult.Message.Header.Type, syncbase_RowDelete_Name; got != want { |
| err = &bindings.ValidationError{bindings.MessageHeaderUnknownMethod, |
| fmt.Sprintf("invalid method in response: expected %v, got %v", want, got), |
| } |
| return |
| } |
| var response syncbase_RowDelete_ResponseParams |
| if err = readResult.Message.DecodePayload(&response); err != nil { |
| p.Close_Proxy() |
| return |
| } |
| outErr = response.outErr |
| return |
| } |
| |
| type syncbase_Stub struct { |
| connector *bindings.Connector |
| impl Syncbase |
| } |
| |
| func NewSyncbaseStub(r Syncbase_Request, impl Syncbase, waiter bindings.AsyncWaiter) *bindings.Stub { |
| connector := bindings.NewConnector(r.PassMessagePipe(), waiter) |
| return bindings.NewStub(connector, &syncbase_Stub{connector, impl}) |
| } |
| |
| func (s *syncbase_Stub) Accept(message *bindings.Message) (err error) { |
| switch message.Header.Type { |
| case syncbase_ServiceGetPermissions_Name: |
| if message.Header.Flags != bindings.MessageExpectsResponseFlag { |
| return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", message.Header.Flags), |
| } |
| } |
| var request syncbase_ServiceGetPermissions_Params |
| if err := message.DecodePayload(&request); err != nil { |
| return err |
| } |
| var response syncbase_ServiceGetPermissions_ResponseParams |
| response.outErr, response.outPerms, response.outVersion, err = s.impl.ServiceGetPermissions() |
| if err != nil { |
| return |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_ServiceGetPermissions_Name, |
| Flags: bindings.MessageIsResponseFlag, |
| RequestId: message.Header.RequestId, |
| } |
| message, err = bindings.EncodeMessage(header, &response) |
| if err != nil { |
| return err |
| } |
| return s.connector.WriteMessage(message) |
| case syncbase_ServiceSetPermissions_Name: |
| if message.Header.Flags != bindings.MessageExpectsResponseFlag { |
| return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", message.Header.Flags), |
| } |
| } |
| var request syncbase_ServiceSetPermissions_Params |
| if err := message.DecodePayload(&request); err != nil { |
| return err |
| } |
| var response syncbase_ServiceSetPermissions_ResponseParams |
| response.outErr, err = s.impl.ServiceSetPermissions(request.inPerms, request.inVersion) |
| if err != nil { |
| return |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_ServiceSetPermissions_Name, |
| Flags: bindings.MessageIsResponseFlag, |
| RequestId: message.Header.RequestId, |
| } |
| message, err = bindings.EncodeMessage(header, &response) |
| if err != nil { |
| return err |
| } |
| return s.connector.WriteMessage(message) |
| case syncbase_AppCreate_Name: |
| if message.Header.Flags != bindings.MessageExpectsResponseFlag { |
| return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", message.Header.Flags), |
| } |
| } |
| var request syncbase_AppCreate_Params |
| if err := message.DecodePayload(&request); err != nil { |
| return err |
| } |
| var response syncbase_AppCreate_ResponseParams |
| response.outErr, err = s.impl.AppCreate(request.inName, request.inPerms) |
| if err != nil { |
| return |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_AppCreate_Name, |
| Flags: bindings.MessageIsResponseFlag, |
| RequestId: message.Header.RequestId, |
| } |
| message, err = bindings.EncodeMessage(header, &response) |
| if err != nil { |
| return err |
| } |
| return s.connector.WriteMessage(message) |
| case syncbase_AppDelete_Name: |
| if message.Header.Flags != bindings.MessageExpectsResponseFlag { |
| return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", message.Header.Flags), |
| } |
| } |
| var request syncbase_AppDelete_Params |
| if err := message.DecodePayload(&request); err != nil { |
| return err |
| } |
| var response syncbase_AppDelete_ResponseParams |
| response.outErr, err = s.impl.AppDelete(request.inName) |
| if err != nil { |
| return |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_AppDelete_Name, |
| Flags: bindings.MessageIsResponseFlag, |
| RequestId: message.Header.RequestId, |
| } |
| message, err = bindings.EncodeMessage(header, &response) |
| if err != nil { |
| return err |
| } |
| return s.connector.WriteMessage(message) |
| case syncbase_AppExists_Name: |
| if message.Header.Flags != bindings.MessageExpectsResponseFlag { |
| return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", message.Header.Flags), |
| } |
| } |
| var request syncbase_AppExists_Params |
| if err := message.DecodePayload(&request); err != nil { |
| return err |
| } |
| var response syncbase_AppExists_ResponseParams |
| response.outErr, response.outExists, err = s.impl.AppExists(request.inName) |
| if err != nil { |
| return |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_AppExists_Name, |
| Flags: bindings.MessageIsResponseFlag, |
| RequestId: message.Header.RequestId, |
| } |
| message, err = bindings.EncodeMessage(header, &response) |
| if err != nil { |
| return err |
| } |
| return s.connector.WriteMessage(message) |
| case syncbase_AppGetPermissions_Name: |
| if message.Header.Flags != bindings.MessageExpectsResponseFlag { |
| return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", message.Header.Flags), |
| } |
| } |
| var request syncbase_AppGetPermissions_Params |
| if err := message.DecodePayload(&request); err != nil { |
| return err |
| } |
| var response syncbase_AppGetPermissions_ResponseParams |
| response.outErr, response.outPerms, response.outVersion, err = s.impl.AppGetPermissions(request.inName) |
| if err != nil { |
| return |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_AppGetPermissions_Name, |
| Flags: bindings.MessageIsResponseFlag, |
| RequestId: message.Header.RequestId, |
| } |
| message, err = bindings.EncodeMessage(header, &response) |
| if err != nil { |
| return err |
| } |
| return s.connector.WriteMessage(message) |
| case syncbase_AppSetPermissions_Name: |
| if message.Header.Flags != bindings.MessageExpectsResponseFlag { |
| return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", message.Header.Flags), |
| } |
| } |
| var request syncbase_AppSetPermissions_Params |
| if err := message.DecodePayload(&request); err != nil { |
| return err |
| } |
| var response syncbase_AppSetPermissions_ResponseParams |
| response.outErr, err = s.impl.AppSetPermissions(request.inName, request.inPerms, request.inVersion) |
| if err != nil { |
| return |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_AppSetPermissions_Name, |
| Flags: bindings.MessageIsResponseFlag, |
| RequestId: message.Header.RequestId, |
| } |
| message, err = bindings.EncodeMessage(header, &response) |
| if err != nil { |
| return err |
| } |
| return s.connector.WriteMessage(message) |
| case syncbase_DbCreate_Name: |
| if message.Header.Flags != bindings.MessageExpectsResponseFlag { |
| return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", message.Header.Flags), |
| } |
| } |
| var request syncbase_DbCreate_Params |
| if err := message.DecodePayload(&request); err != nil { |
| return err |
| } |
| var response syncbase_DbCreate_ResponseParams |
| response.outErr, err = s.impl.DbCreate(request.inName, request.inPerms) |
| if err != nil { |
| return |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_DbCreate_Name, |
| Flags: bindings.MessageIsResponseFlag, |
| RequestId: message.Header.RequestId, |
| } |
| message, err = bindings.EncodeMessage(header, &response) |
| if err != nil { |
| return err |
| } |
| return s.connector.WriteMessage(message) |
| case syncbase_DbDelete_Name: |
| if message.Header.Flags != bindings.MessageExpectsResponseFlag { |
| return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", message.Header.Flags), |
| } |
| } |
| var request syncbase_DbDelete_Params |
| if err := message.DecodePayload(&request); err != nil { |
| return err |
| } |
| var response syncbase_DbDelete_ResponseParams |
| response.outErr, err = s.impl.DbDelete(request.inName) |
| if err != nil { |
| return |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_DbDelete_Name, |
| Flags: bindings.MessageIsResponseFlag, |
| RequestId: message.Header.RequestId, |
| } |
| message, err = bindings.EncodeMessage(header, &response) |
| if err != nil { |
| return err |
| } |
| return s.connector.WriteMessage(message) |
| case syncbase_DbExists_Name: |
| if message.Header.Flags != bindings.MessageExpectsResponseFlag { |
| return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", message.Header.Flags), |
| } |
| } |
| var request syncbase_DbExists_Params |
| if err := message.DecodePayload(&request); err != nil { |
| return err |
| } |
| var response syncbase_DbExists_ResponseParams |
| response.outErr, response.outExists, err = s.impl.DbExists(request.inName) |
| if err != nil { |
| return |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_DbExists_Name, |
| Flags: bindings.MessageIsResponseFlag, |
| RequestId: message.Header.RequestId, |
| } |
| message, err = bindings.EncodeMessage(header, &response) |
| if err != nil { |
| return err |
| } |
| return s.connector.WriteMessage(message) |
| case syncbase_DbExec_Name: |
| if message.Header.Flags != bindings.MessageExpectsResponseFlag { |
| return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", message.Header.Flags), |
| } |
| } |
| var request syncbase_DbExec_Params |
| if err := message.DecodePayload(&request); err != nil { |
| return err |
| } |
| var response syncbase_DbExec_ResponseParams |
| response.outErr, err = s.impl.DbExec(request.inQuery) |
| if err != nil { |
| return |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_DbExec_Name, |
| Flags: bindings.MessageIsResponseFlag, |
| RequestId: message.Header.RequestId, |
| } |
| message, err = bindings.EncodeMessage(header, &response) |
| if err != nil { |
| return err |
| } |
| return s.connector.WriteMessage(message) |
| case syncbase_DbBeginBatch_Name: |
| if message.Header.Flags != bindings.MessageExpectsResponseFlag { |
| return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", message.Header.Flags), |
| } |
| } |
| var request syncbase_DbBeginBatch_Params |
| if err := message.DecodePayload(&request); err != nil { |
| return err |
| } |
| var response syncbase_DbBeginBatch_ResponseParams |
| response.outErr, response.outBatchDn, err = s.impl.DbBeginBatch(request.inName, request.inBo) |
| if err != nil { |
| return |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_DbBeginBatch_Name, |
| Flags: bindings.MessageIsResponseFlag, |
| RequestId: message.Header.RequestId, |
| } |
| message, err = bindings.EncodeMessage(header, &response) |
| if err != nil { |
| return err |
| } |
| return s.connector.WriteMessage(message) |
| case syncbase_DbCommit_Name: |
| if message.Header.Flags != bindings.MessageExpectsResponseFlag { |
| return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", message.Header.Flags), |
| } |
| } |
| var request syncbase_DbCommit_Params |
| if err := message.DecodePayload(&request); err != nil { |
| return err |
| } |
| var response syncbase_DbCommit_ResponseParams |
| response.outErr, err = s.impl.DbCommit(request.inName) |
| if err != nil { |
| return |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_DbCommit_Name, |
| Flags: bindings.MessageIsResponseFlag, |
| RequestId: message.Header.RequestId, |
| } |
| message, err = bindings.EncodeMessage(header, &response) |
| if err != nil { |
| return err |
| } |
| return s.connector.WriteMessage(message) |
| case syncbase_DbAbort_Name: |
| if message.Header.Flags != bindings.MessageExpectsResponseFlag { |
| return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", message.Header.Flags), |
| } |
| } |
| var request syncbase_DbAbort_Params |
| if err := message.DecodePayload(&request); err != nil { |
| return err |
| } |
| var response syncbase_DbAbort_ResponseParams |
| response.outErr, err = s.impl.DbAbort(request.inName) |
| if err != nil { |
| return |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_DbAbort_Name, |
| Flags: bindings.MessageIsResponseFlag, |
| RequestId: message.Header.RequestId, |
| } |
| message, err = bindings.EncodeMessage(header, &response) |
| if err != nil { |
| return err |
| } |
| return s.connector.WriteMessage(message) |
| case syncbase_DbGetPermissions_Name: |
| if message.Header.Flags != bindings.MessageExpectsResponseFlag { |
| return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", message.Header.Flags), |
| } |
| } |
| var request syncbase_DbGetPermissions_Params |
| if err := message.DecodePayload(&request); err != nil { |
| return err |
| } |
| var response syncbase_DbGetPermissions_ResponseParams |
| response.outErr, response.outPerms, response.outVersion, err = s.impl.DbGetPermissions(request.inName) |
| if err != nil { |
| return |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_DbGetPermissions_Name, |
| Flags: bindings.MessageIsResponseFlag, |
| RequestId: message.Header.RequestId, |
| } |
| message, err = bindings.EncodeMessage(header, &response) |
| if err != nil { |
| return err |
| } |
| return s.connector.WriteMessage(message) |
| case syncbase_DbSetPermissions_Name: |
| if message.Header.Flags != bindings.MessageExpectsResponseFlag { |
| return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", message.Header.Flags), |
| } |
| } |
| var request syncbase_DbSetPermissions_Params |
| if err := message.DecodePayload(&request); err != nil { |
| return err |
| } |
| var response syncbase_DbSetPermissions_ResponseParams |
| response.outErr, err = s.impl.DbSetPermissions(request.inName, request.inPerms, request.inVersion) |
| if err != nil { |
| return |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_DbSetPermissions_Name, |
| Flags: bindings.MessageIsResponseFlag, |
| RequestId: message.Header.RequestId, |
| } |
| message, err = bindings.EncodeMessage(header, &response) |
| if err != nil { |
| return err |
| } |
| return s.connector.WriteMessage(message) |
| case syncbase_DbGetSyncGroupNames_Name: |
| if message.Header.Flags != bindings.MessageExpectsResponseFlag { |
| return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", message.Header.Flags), |
| } |
| } |
| var request syncbase_DbGetSyncGroupNames_Params |
| if err := message.DecodePayload(&request); err != nil { |
| return err |
| } |
| var response syncbase_DbGetSyncGroupNames_ResponseParams |
| response.outErr, response.outNames, err = s.impl.DbGetSyncGroupNames(request.inName) |
| if err != nil { |
| return |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_DbGetSyncGroupNames_Name, |
| Flags: bindings.MessageIsResponseFlag, |
| RequestId: message.Header.RequestId, |
| } |
| message, err = bindings.EncodeMessage(header, &response) |
| if err != nil { |
| return err |
| } |
| return s.connector.WriteMessage(message) |
| case syncbase_DbCreateSyncGroup_Name: |
| if message.Header.Flags != bindings.MessageExpectsResponseFlag { |
| return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", message.Header.Flags), |
| } |
| } |
| var request syncbase_DbCreateSyncGroup_Params |
| if err := message.DecodePayload(&request); err != nil { |
| return err |
| } |
| var response syncbase_DbCreateSyncGroup_ResponseParams |
| response.outErr, err = s.impl.DbCreateSyncGroup(request.inName, request.inSgName, request.inSpec, request.inMyInfo) |
| if err != nil { |
| return |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_DbCreateSyncGroup_Name, |
| Flags: bindings.MessageIsResponseFlag, |
| RequestId: message.Header.RequestId, |
| } |
| message, err = bindings.EncodeMessage(header, &response) |
| if err != nil { |
| return err |
| } |
| return s.connector.WriteMessage(message) |
| case syncbase_DbJoinSyncGroup_Name: |
| if message.Header.Flags != bindings.MessageExpectsResponseFlag { |
| return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", message.Header.Flags), |
| } |
| } |
| var request syncbase_DbJoinSyncGroup_Params |
| if err := message.DecodePayload(&request); err != nil { |
| return err |
| } |
| var response syncbase_DbJoinSyncGroup_ResponseParams |
| response.outErr, err = s.impl.DbJoinSyncGroup(request.inName, request.inSgName, request.inMyInfo) |
| if err != nil { |
| return |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_DbJoinSyncGroup_Name, |
| Flags: bindings.MessageIsResponseFlag, |
| RequestId: message.Header.RequestId, |
| } |
| message, err = bindings.EncodeMessage(header, &response) |
| if err != nil { |
| return err |
| } |
| return s.connector.WriteMessage(message) |
| case syncbase_DbLeaveSyncGroup_Name: |
| if message.Header.Flags != bindings.MessageExpectsResponseFlag { |
| return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", message.Header.Flags), |
| } |
| } |
| var request syncbase_DbLeaveSyncGroup_Params |
| if err := message.DecodePayload(&request); err != nil { |
| return err |
| } |
| var response syncbase_DbLeaveSyncGroup_ResponseParams |
| response.outErr, err = s.impl.DbLeaveSyncGroup(request.inName, request.inSgName) |
| if err != nil { |
| return |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_DbLeaveSyncGroup_Name, |
| Flags: bindings.MessageIsResponseFlag, |
| RequestId: message.Header.RequestId, |
| } |
| message, err = bindings.EncodeMessage(header, &response) |
| if err != nil { |
| return err |
| } |
| return s.connector.WriteMessage(message) |
| case syncbase_DbDestroySyncGroup_Name: |
| if message.Header.Flags != bindings.MessageExpectsResponseFlag { |
| return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", message.Header.Flags), |
| } |
| } |
| var request syncbase_DbDestroySyncGroup_Params |
| if err := message.DecodePayload(&request); err != nil { |
| return err |
| } |
| var response syncbase_DbDestroySyncGroup_ResponseParams |
| response.outErr, err = s.impl.DbDestroySyncGroup(request.inName, request.inSgName) |
| if err != nil { |
| return |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_DbDestroySyncGroup_Name, |
| Flags: bindings.MessageIsResponseFlag, |
| RequestId: message.Header.RequestId, |
| } |
| message, err = bindings.EncodeMessage(header, &response) |
| if err != nil { |
| return err |
| } |
| return s.connector.WriteMessage(message) |
| case syncbase_DbEjectFromSyncGroup_Name: |
| if message.Header.Flags != bindings.MessageExpectsResponseFlag { |
| return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", message.Header.Flags), |
| } |
| } |
| var request syncbase_DbEjectFromSyncGroup_Params |
| if err := message.DecodePayload(&request); err != nil { |
| return err |
| } |
| var response syncbase_DbEjectFromSyncGroup_ResponseParams |
| response.outErr, err = s.impl.DbEjectFromSyncGroup(request.inName, request.inSgName, request.inMember) |
| if err != nil { |
| return |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_DbEjectFromSyncGroup_Name, |
| Flags: bindings.MessageIsResponseFlag, |
| RequestId: message.Header.RequestId, |
| } |
| message, err = bindings.EncodeMessage(header, &response) |
| if err != nil { |
| return err |
| } |
| return s.connector.WriteMessage(message) |
| case syncbase_DbGetSyncGroupSpec_Name: |
| if message.Header.Flags != bindings.MessageExpectsResponseFlag { |
| return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", message.Header.Flags), |
| } |
| } |
| var request syncbase_DbGetSyncGroupSpec_Params |
| if err := message.DecodePayload(&request); err != nil { |
| return err |
| } |
| var response syncbase_DbGetSyncGroupSpec_ResponseParams |
| response.outErr, response.outSpec, response.outVersion, err = s.impl.DbGetSyncGroupSpec(request.inName, request.inSgName) |
| if err != nil { |
| return |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_DbGetSyncGroupSpec_Name, |
| Flags: bindings.MessageIsResponseFlag, |
| RequestId: message.Header.RequestId, |
| } |
| message, err = bindings.EncodeMessage(header, &response) |
| if err != nil { |
| return err |
| } |
| return s.connector.WriteMessage(message) |
| case syncbase_DbSetSyncGroupSpec_Name: |
| if message.Header.Flags != bindings.MessageExpectsResponseFlag { |
| return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", message.Header.Flags), |
| } |
| } |
| var request syncbase_DbSetSyncGroupSpec_Params |
| if err := message.DecodePayload(&request); err != nil { |
| return err |
| } |
| var response syncbase_DbSetSyncGroupSpec_ResponseParams |
| response.outErr, err = s.impl.DbSetSyncGroupSpec(request.inName, request.inSgName, request.inSpec, request.inVersion) |
| if err != nil { |
| return |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_DbSetSyncGroupSpec_Name, |
| Flags: bindings.MessageIsResponseFlag, |
| RequestId: message.Header.RequestId, |
| } |
| message, err = bindings.EncodeMessage(header, &response) |
| if err != nil { |
| return err |
| } |
| return s.connector.WriteMessage(message) |
| case syncbase_DbGetSyncGroupMembers_Name: |
| if message.Header.Flags != bindings.MessageExpectsResponseFlag { |
| return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", message.Header.Flags), |
| } |
| } |
| var request syncbase_DbGetSyncGroupMembers_Params |
| if err := message.DecodePayload(&request); err != nil { |
| return err |
| } |
| var response syncbase_DbGetSyncGroupMembers_ResponseParams |
| response.outErr, response.outInfos, err = s.impl.DbGetSyncGroupMembers(request.inName, request.inSgName) |
| if err != nil { |
| return |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_DbGetSyncGroupMembers_Name, |
| Flags: bindings.MessageIsResponseFlag, |
| RequestId: message.Header.RequestId, |
| } |
| message, err = bindings.EncodeMessage(header, &response) |
| if err != nil { |
| return err |
| } |
| return s.connector.WriteMessage(message) |
| case syncbase_TableCreate_Name: |
| if message.Header.Flags != bindings.MessageExpectsResponseFlag { |
| return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", message.Header.Flags), |
| } |
| } |
| var request syncbase_TableCreate_Params |
| if err := message.DecodePayload(&request); err != nil { |
| return err |
| } |
| var response syncbase_TableCreate_ResponseParams |
| response.outErr, err = s.impl.TableCreate(request.inName, request.inPerms) |
| if err != nil { |
| return |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_TableCreate_Name, |
| Flags: bindings.MessageIsResponseFlag, |
| RequestId: message.Header.RequestId, |
| } |
| message, err = bindings.EncodeMessage(header, &response) |
| if err != nil { |
| return err |
| } |
| return s.connector.WriteMessage(message) |
| case syncbase_TableDelete_Name: |
| if message.Header.Flags != bindings.MessageExpectsResponseFlag { |
| return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", message.Header.Flags), |
| } |
| } |
| var request syncbase_TableDelete_Params |
| if err := message.DecodePayload(&request); err != nil { |
| return err |
| } |
| var response syncbase_TableDelete_ResponseParams |
| response.outErr, err = s.impl.TableDelete(request.inName) |
| if err != nil { |
| return |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_TableDelete_Name, |
| Flags: bindings.MessageIsResponseFlag, |
| RequestId: message.Header.RequestId, |
| } |
| message, err = bindings.EncodeMessage(header, &response) |
| if err != nil { |
| return err |
| } |
| return s.connector.WriteMessage(message) |
| case syncbase_TableExists_Name: |
| if message.Header.Flags != bindings.MessageExpectsResponseFlag { |
| return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", message.Header.Flags), |
| } |
| } |
| var request syncbase_TableExists_Params |
| if err := message.DecodePayload(&request); err != nil { |
| return err |
| } |
| var response syncbase_TableExists_ResponseParams |
| response.outErr, response.outExists, err = s.impl.TableExists(request.inName) |
| if err != nil { |
| return |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_TableExists_Name, |
| Flags: bindings.MessageIsResponseFlag, |
| RequestId: message.Header.RequestId, |
| } |
| message, err = bindings.EncodeMessage(header, &response) |
| if err != nil { |
| return err |
| } |
| return s.connector.WriteMessage(message) |
| case syncbase_TableDeleteRowRange_Name: |
| if message.Header.Flags != bindings.MessageExpectsResponseFlag { |
| return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", message.Header.Flags), |
| } |
| } |
| var request syncbase_TableDeleteRowRange_Params |
| if err := message.DecodePayload(&request); err != nil { |
| return err |
| } |
| var response syncbase_TableDeleteRowRange_ResponseParams |
| response.outErr, err = s.impl.TableDeleteRowRange(request.inName, request.inStart, request.inLimit) |
| if err != nil { |
| return |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_TableDeleteRowRange_Name, |
| Flags: bindings.MessageIsResponseFlag, |
| RequestId: message.Header.RequestId, |
| } |
| message, err = bindings.EncodeMessage(header, &response) |
| if err != nil { |
| return err |
| } |
| return s.connector.WriteMessage(message) |
| case syncbase_TableScan_Name: |
| if message.Header.Flags != bindings.MessageExpectsResponseFlag { |
| return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", message.Header.Flags), |
| } |
| } |
| var request syncbase_TableScan_Params |
| if err := message.DecodePayload(&request); err != nil { |
| return err |
| } |
| var response syncbase_TableScan_ResponseParams |
| response.outErr, err = s.impl.TableScan(request.inName, request.inStart, request.inLimit) |
| if err != nil { |
| return |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_TableScan_Name, |
| Flags: bindings.MessageIsResponseFlag, |
| RequestId: message.Header.RequestId, |
| } |
| message, err = bindings.EncodeMessage(header, &response) |
| if err != nil { |
| return err |
| } |
| return s.connector.WriteMessage(message) |
| case syncbase_TableGetPermissions_Name: |
| if message.Header.Flags != bindings.MessageExpectsResponseFlag { |
| return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", message.Header.Flags), |
| } |
| } |
| var request syncbase_TableGetPermissions_Params |
| if err := message.DecodePayload(&request); err != nil { |
| return err |
| } |
| var response syncbase_TableGetPermissions_ResponseParams |
| response.outErr, response.outPermsArr, err = s.impl.TableGetPermissions(request.inName, request.inKey) |
| if err != nil { |
| return |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_TableGetPermissions_Name, |
| Flags: bindings.MessageIsResponseFlag, |
| RequestId: message.Header.RequestId, |
| } |
| message, err = bindings.EncodeMessage(header, &response) |
| if err != nil { |
| return err |
| } |
| return s.connector.WriteMessage(message) |
| case syncbase_TableSetPermissions_Name: |
| if message.Header.Flags != bindings.MessageExpectsResponseFlag { |
| return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", message.Header.Flags), |
| } |
| } |
| var request syncbase_TableSetPermissions_Params |
| if err := message.DecodePayload(&request); err != nil { |
| return err |
| } |
| var response syncbase_TableSetPermissions_ResponseParams |
| response.outErr, err = s.impl.TableSetPermissions(request.inName, request.inPrefix, request.inPerms) |
| if err != nil { |
| return |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_TableSetPermissions_Name, |
| Flags: bindings.MessageIsResponseFlag, |
| RequestId: message.Header.RequestId, |
| } |
| message, err = bindings.EncodeMessage(header, &response) |
| if err != nil { |
| return err |
| } |
| return s.connector.WriteMessage(message) |
| case syncbase_TableDeletePermissions_Name: |
| if message.Header.Flags != bindings.MessageExpectsResponseFlag { |
| return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", message.Header.Flags), |
| } |
| } |
| var request syncbase_TableDeletePermissions_Params |
| if err := message.DecodePayload(&request); err != nil { |
| return err |
| } |
| var response syncbase_TableDeletePermissions_ResponseParams |
| response.outErr, err = s.impl.TableDeletePermissions(request.inName, request.inPrefix) |
| if err != nil { |
| return |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_TableDeletePermissions_Name, |
| Flags: bindings.MessageIsResponseFlag, |
| RequestId: message.Header.RequestId, |
| } |
| message, err = bindings.EncodeMessage(header, &response) |
| if err != nil { |
| return err |
| } |
| return s.connector.WriteMessage(message) |
| case syncbase_RowExists_Name: |
| if message.Header.Flags != bindings.MessageExpectsResponseFlag { |
| return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", message.Header.Flags), |
| } |
| } |
| var request syncbase_RowExists_Params |
| if err := message.DecodePayload(&request); err != nil { |
| return err |
| } |
| var response syncbase_RowExists_ResponseParams |
| response.outErr, response.outExists, err = s.impl.RowExists(request.inName) |
| if err != nil { |
| return |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_RowExists_Name, |
| Flags: bindings.MessageIsResponseFlag, |
| RequestId: message.Header.RequestId, |
| } |
| message, err = bindings.EncodeMessage(header, &response) |
| if err != nil { |
| return err |
| } |
| return s.connector.WriteMessage(message) |
| case syncbase_RowGet_Name: |
| if message.Header.Flags != bindings.MessageExpectsResponseFlag { |
| return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", message.Header.Flags), |
| } |
| } |
| var request syncbase_RowGet_Params |
| if err := message.DecodePayload(&request); err != nil { |
| return err |
| } |
| var response syncbase_RowGet_ResponseParams |
| response.outErr, response.outValue, err = s.impl.RowGet(request.inName) |
| if err != nil { |
| return |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_RowGet_Name, |
| Flags: bindings.MessageIsResponseFlag, |
| RequestId: message.Header.RequestId, |
| } |
| message, err = bindings.EncodeMessage(header, &response) |
| if err != nil { |
| return err |
| } |
| return s.connector.WriteMessage(message) |
| case syncbase_RowPut_Name: |
| if message.Header.Flags != bindings.MessageExpectsResponseFlag { |
| return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", message.Header.Flags), |
| } |
| } |
| var request syncbase_RowPut_Params |
| if err := message.DecodePayload(&request); err != nil { |
| return err |
| } |
| var response syncbase_RowPut_ResponseParams |
| response.outErr, err = s.impl.RowPut(request.inName, request.inValue) |
| if err != nil { |
| return |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_RowPut_Name, |
| Flags: bindings.MessageIsResponseFlag, |
| RequestId: message.Header.RequestId, |
| } |
| message, err = bindings.EncodeMessage(header, &response) |
| if err != nil { |
| return err |
| } |
| return s.connector.WriteMessage(message) |
| case syncbase_RowDelete_Name: |
| if message.Header.Flags != bindings.MessageExpectsResponseFlag { |
| return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags, |
| fmt.Sprintf("invalid message header flag: %v", message.Header.Flags), |
| } |
| } |
| var request syncbase_RowDelete_Params |
| if err := message.DecodePayload(&request); err != nil { |
| return err |
| } |
| var response syncbase_RowDelete_ResponseParams |
| response.outErr, err = s.impl.RowDelete(request.inName) |
| if err != nil { |
| return |
| } |
| header := bindings.MessageHeader{ |
| Type: syncbase_RowDelete_Name, |
| Flags: bindings.MessageIsResponseFlag, |
| RequestId: message.Header.RequestId, |
| } |
| message, err = bindings.EncodeMessage(header, &response) |
| if err != nil { |
| return err |
| } |
| return s.connector.WriteMessage(message) |
| default: |
| return &bindings.ValidationError{ |
| bindings.MessageHeaderUnknownMethod, |
| fmt.Sprintf("unknown method %v", message.Header.Type), |
| } |
| } |
| return |
| } |
| |
| type Error struct { |
| Id string |
| ActionCode uint32 |
| Msg string |
| } |
| |
| func (s *Error) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(24, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.Id); err != nil { |
| return err |
| } |
| if err := encoder.WriteUint32(s.ActionCode); err != nil { |
| return err |
| } |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.Msg); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var error_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{32, 0}, |
| } |
| |
| func (s *Error) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(error_Versions), func(i int) bool { |
| return error_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(error_Versions) { |
| if error_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := error_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.Id = value0 |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| value0, err := decoder.ReadUint32() |
| if err != nil { |
| return err |
| } |
| s.ActionCode = value0 |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.Msg = value0 |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| type Perms struct { |
| Json string |
| } |
| |
| func (s *Perms) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(8, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.Json); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var perms_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{16, 0}, |
| } |
| |
| func (s *Perms) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(perms_Versions), func(i int) bool { |
| return perms_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(perms_Versions) { |
| if perms_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := perms_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.Json = value0 |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| type BatchOptions struct { |
| Hint string |
| ReadOnly bool |
| } |
| |
| func (s *BatchOptions) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(16, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.Hint); err != nil { |
| return err |
| } |
| if err := encoder.WriteBool(s.ReadOnly); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var batchOptions_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{24, 0}, |
| } |
| |
| func (s *BatchOptions) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(batchOptions_Versions), func(i int) bool { |
| return batchOptions_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(batchOptions_Versions) { |
| if batchOptions_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := batchOptions_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.Hint = value0 |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| value0, err := decoder.ReadBool() |
| if err != nil { |
| return err |
| } |
| s.ReadOnly = value0 |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| type PrefixPerms struct { |
| Prefix string |
| Perms Perms |
| } |
| |
| func (s *PrefixPerms) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(16, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.Prefix); err != nil { |
| return err |
| } |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.Perms.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var prefixPerms_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{24, 0}, |
| } |
| |
| func (s *PrefixPerms) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(prefixPerms_Versions), func(i int) bool { |
| return prefixPerms_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(prefixPerms_Versions) { |
| if prefixPerms_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := prefixPerms_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.Prefix = value0 |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.Perms.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| type SyncGroupSpec struct { |
| Description string |
| Perms Perms |
| Prefixes []string |
| MountTables []string |
| IsPrivate bool |
| } |
| |
| func (s *SyncGroupSpec) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(40, 0) |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(s.Description); err != nil { |
| return err |
| } |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := s.Perms.Encode(encoder); err != nil { |
| return err |
| } |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| encoder.StartArray(uint32(len(s.Prefixes)), 64) |
| for _, elem0 := range s.Prefixes { |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(elem0); err != nil { |
| return err |
| } |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| encoder.StartArray(uint32(len(s.MountTables)), 64) |
| for _, elem0 := range s.MountTables { |
| if err := encoder.WritePointer(); err != nil { |
| return err |
| } |
| if err := encoder.WriteString(elem0); err != nil { |
| return err |
| } |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| if err := encoder.WriteBool(s.IsPrivate); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncGroupSpec_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{48, 0}, |
| } |
| |
| func (s *SyncGroupSpec) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncGroupSpec_Versions), func(i int) bool { |
| return syncGroupSpec_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncGroupSpec_Versions) { |
| if syncGroupSpec_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncGroupSpec_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value0, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.Description = value0 |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| if err := s.Perms.Decode(decoder); err != nil { |
| return err |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| len0, err := decoder.StartArray(64) |
| if err != nil { |
| return err |
| } |
| s.Prefixes = make([]string, len0) |
| for i0 := uint32(0); i0 < len0; i0++ { |
| pointer1, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer1 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value1, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.Prefixes[i0] = value1 |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| pointer0, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer0 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| len0, err := decoder.StartArray(64) |
| if err != nil { |
| return err |
| } |
| s.MountTables = make([]string, len0) |
| for i0 := uint32(0); i0 < len0; i0++ { |
| pointer1, err := decoder.ReadPointer() |
| if err != nil { |
| return err |
| } |
| if pointer1 == 0 { |
| return &bindings.ValidationError{bindings.UnexpectedNullPointer, "unexpected null pointer"} |
| } else { |
| value1, err := decoder.ReadString() |
| if err != nil { |
| return err |
| } |
| s.MountTables[i0] = value1 |
| } |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| value0, err := decoder.ReadBool() |
| if err != nil { |
| return err |
| } |
| s.IsPrivate = value0 |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| type SyncGroupMemberInfo struct { |
| SyncPriority uint8 |
| } |
| |
| func (s *SyncGroupMemberInfo) Encode(encoder *bindings.Encoder) error { |
| encoder.StartStruct(8, 0) |
| if err := encoder.WriteUint8(s.SyncPriority); err != nil { |
| return err |
| } |
| if err := encoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |
| |
| var syncGroupMemberInfo_Versions []bindings.DataHeader = []bindings.DataHeader{ |
| bindings.DataHeader{16, 0}, |
| } |
| |
| func (s *SyncGroupMemberInfo) Decode(decoder *bindings.Decoder) error { |
| header, err := decoder.StartStruct() |
| if err != nil { |
| return err |
| } |
| index := sort.Search(len(syncGroupMemberInfo_Versions), func(i int) bool { |
| return syncGroupMemberInfo_Versions[i].ElementsOrVersion >= header.ElementsOrVersion |
| }) |
| if index < len(syncGroupMemberInfo_Versions) { |
| if syncGroupMemberInfo_Versions[index].ElementsOrVersion > header.ElementsOrVersion { |
| index-- |
| } |
| expectedSize := syncGroupMemberInfo_Versions[index].Size |
| if expectedSize != header.Size { |
| return &bindings.ValidationError{bindings.UnexpectedStructHeader, |
| fmt.Sprintf("invalid struct header size: should be %d, but was %d", expectedSize, header.Size), |
| } |
| } |
| } |
| if header.ElementsOrVersion >= 0 { |
| value0, err := decoder.ReadUint8() |
| if err != nil { |
| return err |
| } |
| s.SyncPriority = value0 |
| } |
| if err := decoder.Finish(); err != nil { |
| return err |
| } |
| return nil |
| } |