blob: c2147c08b2af43ac6afa544a59f09250ec3c5f1a [file] [log] [blame]
// 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/vanadium/discovery.mojom
//
package discovery
import (
"fmt"
"mojo/public/go/bindings"
"mojo/public/go/system"
"sort"
)
type Advertiser interface {
Advertise(inS Service, inVisibility []string) (outHandle uint32, outErr *Error, err error)
Stop(inH uint32) (err error)
}
var advertiser_Name = "discovery::Advertiser"
type Advertiser_Request bindings.InterfaceRequest
func (r *Advertiser_Request) Name() string {
return advertiser_Name
}
type Advertiser_Pointer bindings.InterfacePointer
func (p *Advertiser_Pointer) Name() string {
return advertiser_Name
}
type Advertiser_ServiceFactory struct {
Delegate Advertiser_Factory
}
type Advertiser_Factory interface {
Create(request Advertiser_Request)
}
func (f *Advertiser_ServiceFactory) Name() string {
return advertiser_Name
}
func (f *Advertiser_ServiceFactory) Create(messagePipe system.MessagePipeHandle) {
request := Advertiser_Request{bindings.NewMessagePipeHandleOwner(messagePipe)}
f.Delegate.Create(request)
}
// CreateMessagePipeForAdvertiser creates a message pipe for use with the
// Advertiser interface with a Advertiser_Request on one end and a Advertiser_Pointer on the other.
func CreateMessagePipeForAdvertiser() (Advertiser_Request, Advertiser_Pointer) {
r, p := bindings.CreateMessagePipeForMojoInterface()
return Advertiser_Request(r), Advertiser_Pointer(p)
}
const advertiser_Advertise_Name uint32 = 0
const advertiser_Stop_Name uint32 = 1
type Advertiser_Proxy struct {
router *bindings.Router
ids bindings.Counter
}
func NewAdvertiserProxy(p Advertiser_Pointer, waiter bindings.AsyncWaiter) *Advertiser_Proxy {
return &Advertiser_Proxy{
bindings.NewRouter(p.PassMessagePipe(), waiter),
bindings.NewCounter(),
}
}
func (p *Advertiser_Proxy) Close_Proxy() {
p.router.Close()
}
type advertiser_Advertise_Params struct {
inS Service
inVisibility []string
}
func (s *advertiser_Advertise_Params) Encode(encoder *bindings.Encoder) error {
encoder.StartStruct(16, 0)
if err := encoder.WritePointer(); err != nil {
return err
}
if err := s.inS.Encode(encoder); err != nil {
return err
}
if err := encoder.WritePointer(); err != nil {
return err
}
encoder.StartArray(uint32(len(s.inVisibility)), 64)
for _, elem0 := range s.inVisibility {
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 advertiser_Advertise_Params_Versions []bindings.DataHeader = []bindings.DataHeader{
bindings.DataHeader{24, 0},
}
func (s *advertiser_Advertise_Params) Decode(decoder *bindings.Decoder) error {
header, err := decoder.StartStruct()
if err != nil {
return err
}
index := sort.Search(len(advertiser_Advertise_Params_Versions), func(i int) bool {
return advertiser_Advertise_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
})
if index < len(advertiser_Advertise_Params_Versions) {
if advertiser_Advertise_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
index--
}
expectedSize := advertiser_Advertise_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.inS.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.inVisibility = 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.inVisibility[i0] = value1
}
}
if err := decoder.Finish(); err != nil {
return err
}
}
}
if err := decoder.Finish(); err != nil {
return err
}
return nil
}
type advertiser_Advertise_ResponseParams struct {
outHandle uint32
outErr *Error
}
func (s *advertiser_Advertise_ResponseParams) Encode(encoder *bindings.Encoder) error {
encoder.StartStruct(16, 0)
if err := encoder.WriteUint32(s.outHandle); err != nil {
return err
}
if s.outErr == nil {
encoder.WriteNullPointer()
} else {
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 advertiser_Advertise_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{
bindings.DataHeader{24, 0},
}
func (s *advertiser_Advertise_ResponseParams) Decode(decoder *bindings.Decoder) error {
header, err := decoder.StartStruct()
if err != nil {
return err
}
index := sort.Search(len(advertiser_Advertise_ResponseParams_Versions), func(i int) bool {
return advertiser_Advertise_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
})
if index < len(advertiser_Advertise_ResponseParams_Versions) {
if advertiser_Advertise_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
index--
}
expectedSize := advertiser_Advertise_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 {
value0, err := decoder.ReadUint32()
if err != nil {
return err
}
s.outHandle = value0
}
if header.ElementsOrVersion >= 0 {
pointer0, err := decoder.ReadPointer()
if err != nil {
return err
}
if pointer0 == 0 {
s.outErr = nil
} else {
s.outErr = new(Error)
if err := (*s.outErr).Decode(decoder); err != nil {
return err
}
}
}
if err := decoder.Finish(); err != nil {
return err
}
return nil
}
func (p *Advertiser_Proxy) Advertise(inS Service, inVisibility []string) (outHandle uint32, outErr *Error, err error) {
payload := &advertiser_Advertise_Params{
inS,
inVisibility,
}
header := bindings.MessageHeader{
Type: advertiser_Advertise_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, advertiser_Advertise_Name; got != want {
err = &bindings.ValidationError{bindings.MessageHeaderUnknownMethod,
fmt.Sprintf("invalid method in response: expected %v, got %v", want, got),
}
return
}
var response advertiser_Advertise_ResponseParams
if err = readResult.Message.DecodePayload(&response); err != nil {
p.Close_Proxy()
return
}
outHandle = response.outHandle
outErr = response.outErr
return
}
type advertiser_Stop_Params struct {
inH uint32
}
func (s *advertiser_Stop_Params) Encode(encoder *bindings.Encoder) error {
encoder.StartStruct(8, 0)
if err := encoder.WriteUint32(s.inH); err != nil {
return err
}
if err := encoder.Finish(); err != nil {
return err
}
return nil
}
var advertiser_Stop_Params_Versions []bindings.DataHeader = []bindings.DataHeader{
bindings.DataHeader{16, 0},
}
func (s *advertiser_Stop_Params) Decode(decoder *bindings.Decoder) error {
header, err := decoder.StartStruct()
if err != nil {
return err
}
index := sort.Search(len(advertiser_Stop_Params_Versions), func(i int) bool {
return advertiser_Stop_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
})
if index < len(advertiser_Stop_Params_Versions) {
if advertiser_Stop_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
index--
}
expectedSize := advertiser_Stop_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 {
value0, err := decoder.ReadUint32()
if err != nil {
return err
}
s.inH = value0
}
if err := decoder.Finish(); err != nil {
return err
}
return nil
}
func (p *Advertiser_Proxy) Stop(inH uint32) (err error) {
payload := &advertiser_Stop_Params{
inH,
}
header := bindings.MessageHeader{
Type: advertiser_Stop_Name,
Flags: bindings.MessageNoFlag,
}
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
}
if err = p.router.Accept(message); err != nil {
p.Close_Proxy()
return
}
return
}
type advertiser_Stub struct {
connector *bindings.Connector
impl Advertiser
}
func NewAdvertiserStub(r Advertiser_Request, impl Advertiser, waiter bindings.AsyncWaiter) *bindings.Stub {
connector := bindings.NewConnector(r.PassMessagePipe(), waiter)
return bindings.NewStub(connector, &advertiser_Stub{connector, impl})
}
func (s *advertiser_Stub) Accept(message *bindings.Message) (err error) {
switch message.Header.Type {
case advertiser_Advertise_Name:
if message.Header.Flags != bindings.MessageExpectsResponseFlag {
return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags,
fmt.Sprintf("invalid message header flag: %v", message.Header.Flags),
}
}
var request advertiser_Advertise_Params
if err := message.DecodePayload(&request); err != nil {
return err
}
var response advertiser_Advertise_ResponseParams
response.outHandle, response.outErr, err = s.impl.Advertise(request.inS, request.inVisibility)
if err != nil {
return
}
header := bindings.MessageHeader{
Type: advertiser_Advertise_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 advertiser_Stop_Name:
if message.Header.Flags != bindings.MessageNoFlag {
return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags,
fmt.Sprintf("invalid message header flag: %v", message.Header.Flags),
}
}
var request advertiser_Stop_Params
if err := message.DecodePayload(&request); err != nil {
return err
}
err = s.impl.Stop(request.inH)
if err != nil {
return
}
default:
return &bindings.ValidationError{
bindings.MessageHeaderUnknownMethod,
fmt.Sprintf("unknown method %v", message.Header.Type),
}
}
return
}
type Scanner interface {
Scan(inQuery string, inScanHandler ScanHandler_Pointer) (outHandle uint32, outErr *Error, err error)
Stop(inH uint32) (err error)
}
var scanner_Name = "discovery::Scanner"
type Scanner_Request bindings.InterfaceRequest
func (r *Scanner_Request) Name() string {
return scanner_Name
}
type Scanner_Pointer bindings.InterfacePointer
func (p *Scanner_Pointer) Name() string {
return scanner_Name
}
type Scanner_ServiceFactory struct {
Delegate Scanner_Factory
}
type Scanner_Factory interface {
Create(request Scanner_Request)
}
func (f *Scanner_ServiceFactory) Name() string {
return scanner_Name
}
func (f *Scanner_ServiceFactory) Create(messagePipe system.MessagePipeHandle) {
request := Scanner_Request{bindings.NewMessagePipeHandleOwner(messagePipe)}
f.Delegate.Create(request)
}
// CreateMessagePipeForScanner creates a message pipe for use with the
// Scanner interface with a Scanner_Request on one end and a Scanner_Pointer on the other.
func CreateMessagePipeForScanner() (Scanner_Request, Scanner_Pointer) {
r, p := bindings.CreateMessagePipeForMojoInterface()
return Scanner_Request(r), Scanner_Pointer(p)
}
const scanner_Scan_Name uint32 = 0
const scanner_Stop_Name uint32 = 1
type Scanner_Proxy struct {
router *bindings.Router
ids bindings.Counter
}
func NewScannerProxy(p Scanner_Pointer, waiter bindings.AsyncWaiter) *Scanner_Proxy {
return &Scanner_Proxy{
bindings.NewRouter(p.PassMessagePipe(), waiter),
bindings.NewCounter(),
}
}
func (p *Scanner_Proxy) Close_Proxy() {
p.router.Close()
}
type scanner_Scan_Params struct {
inQuery string
inScanHandler ScanHandler_Pointer
}
func (s *scanner_Scan_Params) Encode(encoder *bindings.Encoder) error {
encoder.StartStruct(16, 0)
if err := encoder.WritePointer(); err != nil {
return err
}
if err := encoder.WriteString(s.inQuery); err != nil {
return err
}
if err := encoder.WriteInterface(s.inScanHandler.PassMessagePipe()); err != nil {
return err
}
if err := encoder.Finish(); err != nil {
return err
}
return nil
}
var scanner_Scan_Params_Versions []bindings.DataHeader = []bindings.DataHeader{
bindings.DataHeader{24, 0},
}
func (s *scanner_Scan_Params) Decode(decoder *bindings.Decoder) error {
header, err := decoder.StartStruct()
if err != nil {
return err
}
index := sort.Search(len(scanner_Scan_Params_Versions), func(i int) bool {
return scanner_Scan_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
})
if index < len(scanner_Scan_Params_Versions) {
if scanner_Scan_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
index--
}
expectedSize := scanner_Scan_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 header.ElementsOrVersion >= 0 {
handle0, err := decoder.ReadInterface()
if err != nil {
return err
}
if handle0.IsValid() {
handleOwner := bindings.NewMessagePipeHandleOwner(handle0)
s.inScanHandler = ScanHandler_Pointer{handleOwner}
} else {
return &bindings.ValidationError{bindings.UnexpectedInvalidHandle, "unexpected invalid handle"}
}
}
if err := decoder.Finish(); err != nil {
return err
}
return nil
}
type scanner_Scan_ResponseParams struct {
outHandle uint32
outErr *Error
}
func (s *scanner_Scan_ResponseParams) Encode(encoder *bindings.Encoder) error {
encoder.StartStruct(16, 0)
if err := encoder.WriteUint32(s.outHandle); err != nil {
return err
}
if s.outErr == nil {
encoder.WriteNullPointer()
} else {
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 scanner_Scan_ResponseParams_Versions []bindings.DataHeader = []bindings.DataHeader{
bindings.DataHeader{24, 0},
}
func (s *scanner_Scan_ResponseParams) Decode(decoder *bindings.Decoder) error {
header, err := decoder.StartStruct()
if err != nil {
return err
}
index := sort.Search(len(scanner_Scan_ResponseParams_Versions), func(i int) bool {
return scanner_Scan_ResponseParams_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
})
if index < len(scanner_Scan_ResponseParams_Versions) {
if scanner_Scan_ResponseParams_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
index--
}
expectedSize := scanner_Scan_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 {
value0, err := decoder.ReadUint32()
if err != nil {
return err
}
s.outHandle = value0
}
if header.ElementsOrVersion >= 0 {
pointer0, err := decoder.ReadPointer()
if err != nil {
return err
}
if pointer0 == 0 {
s.outErr = nil
} else {
s.outErr = new(Error)
if err := (*s.outErr).Decode(decoder); err != nil {
return err
}
}
}
if err := decoder.Finish(); err != nil {
return err
}
return nil
}
func (p *Scanner_Proxy) Scan(inQuery string, inScanHandler ScanHandler_Pointer) (outHandle uint32, outErr *Error, err error) {
payload := &scanner_Scan_Params{
inQuery,
inScanHandler,
}
header := bindings.MessageHeader{
Type: scanner_Scan_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, scanner_Scan_Name; got != want {
err = &bindings.ValidationError{bindings.MessageHeaderUnknownMethod,
fmt.Sprintf("invalid method in response: expected %v, got %v", want, got),
}
return
}
var response scanner_Scan_ResponseParams
if err = readResult.Message.DecodePayload(&response); err != nil {
p.Close_Proxy()
return
}
outHandle = response.outHandle
outErr = response.outErr
return
}
type scanner_Stop_Params struct {
inH uint32
}
func (s *scanner_Stop_Params) Encode(encoder *bindings.Encoder) error {
encoder.StartStruct(8, 0)
if err := encoder.WriteUint32(s.inH); err != nil {
return err
}
if err := encoder.Finish(); err != nil {
return err
}
return nil
}
var scanner_Stop_Params_Versions []bindings.DataHeader = []bindings.DataHeader{
bindings.DataHeader{16, 0},
}
func (s *scanner_Stop_Params) Decode(decoder *bindings.Decoder) error {
header, err := decoder.StartStruct()
if err != nil {
return err
}
index := sort.Search(len(scanner_Stop_Params_Versions), func(i int) bool {
return scanner_Stop_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
})
if index < len(scanner_Stop_Params_Versions) {
if scanner_Stop_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
index--
}
expectedSize := scanner_Stop_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 {
value0, err := decoder.ReadUint32()
if err != nil {
return err
}
s.inH = value0
}
if err := decoder.Finish(); err != nil {
return err
}
return nil
}
func (p *Scanner_Proxy) Stop(inH uint32) (err error) {
payload := &scanner_Stop_Params{
inH,
}
header := bindings.MessageHeader{
Type: scanner_Stop_Name,
Flags: bindings.MessageNoFlag,
}
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
}
if err = p.router.Accept(message); err != nil {
p.Close_Proxy()
return
}
return
}
type scanner_Stub struct {
connector *bindings.Connector
impl Scanner
}
func NewScannerStub(r Scanner_Request, impl Scanner, waiter bindings.AsyncWaiter) *bindings.Stub {
connector := bindings.NewConnector(r.PassMessagePipe(), waiter)
return bindings.NewStub(connector, &scanner_Stub{connector, impl})
}
func (s *scanner_Stub) Accept(message *bindings.Message) (err error) {
switch message.Header.Type {
case scanner_Scan_Name:
if message.Header.Flags != bindings.MessageExpectsResponseFlag {
return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags,
fmt.Sprintf("invalid message header flag: %v", message.Header.Flags),
}
}
var request scanner_Scan_Params
if err := message.DecodePayload(&request); err != nil {
return err
}
var response scanner_Scan_ResponseParams
response.outHandle, response.outErr, err = s.impl.Scan(request.inQuery, request.inScanHandler)
if err != nil {
return
}
header := bindings.MessageHeader{
Type: scanner_Scan_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 scanner_Stop_Name:
if message.Header.Flags != bindings.MessageNoFlag {
return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags,
fmt.Sprintf("invalid message header flag: %v", message.Header.Flags),
}
}
var request scanner_Stop_Params
if err := message.DecodePayload(&request); err != nil {
return err
}
err = s.impl.Stop(request.inH)
if err != nil {
return
}
default:
return &bindings.ValidationError{
bindings.MessageHeaderUnknownMethod,
fmt.Sprintf("unknown method %v", message.Header.Type),
}
}
return
}
type ScanHandler interface {
Found(inS Service) (err error)
Lost(inInstanceId []uint8) (err error)
}
var scanHandler_Name = "discovery::ScanHandler"
type ScanHandler_Request bindings.InterfaceRequest
func (r *ScanHandler_Request) Name() string {
return scanHandler_Name
}
type ScanHandler_Pointer bindings.InterfacePointer
func (p *ScanHandler_Pointer) Name() string {
return scanHandler_Name
}
type ScanHandler_ServiceFactory struct {
Delegate ScanHandler_Factory
}
type ScanHandler_Factory interface {
Create(request ScanHandler_Request)
}
func (f *ScanHandler_ServiceFactory) Name() string {
return scanHandler_Name
}
func (f *ScanHandler_ServiceFactory) Create(messagePipe system.MessagePipeHandle) {
request := ScanHandler_Request{bindings.NewMessagePipeHandleOwner(messagePipe)}
f.Delegate.Create(request)
}
// CreateMessagePipeForScanHandler creates a message pipe for use with the
// ScanHandler interface with a ScanHandler_Request on one end and a ScanHandler_Pointer on the other.
func CreateMessagePipeForScanHandler() (ScanHandler_Request, ScanHandler_Pointer) {
r, p := bindings.CreateMessagePipeForMojoInterface()
return ScanHandler_Request(r), ScanHandler_Pointer(p)
}
const scanHandler_Found_Name uint32 = 0
const scanHandler_Lost_Name uint32 = 1
type ScanHandler_Proxy struct {
router *bindings.Router
ids bindings.Counter
}
func NewScanHandlerProxy(p ScanHandler_Pointer, waiter bindings.AsyncWaiter) *ScanHandler_Proxy {
return &ScanHandler_Proxy{
bindings.NewRouter(p.PassMessagePipe(), waiter),
bindings.NewCounter(),
}
}
func (p *ScanHandler_Proxy) Close_Proxy() {
p.router.Close()
}
type scanHandler_Found_Params struct {
inS Service
}
func (s *scanHandler_Found_Params) Encode(encoder *bindings.Encoder) error {
encoder.StartStruct(8, 0)
if err := encoder.WritePointer(); err != nil {
return err
}
if err := s.inS.Encode(encoder); err != nil {
return err
}
if err := encoder.Finish(); err != nil {
return err
}
return nil
}
var scanHandler_Found_Params_Versions []bindings.DataHeader = []bindings.DataHeader{
bindings.DataHeader{16, 0},
}
func (s *scanHandler_Found_Params) Decode(decoder *bindings.Decoder) error {
header, err := decoder.StartStruct()
if err != nil {
return err
}
index := sort.Search(len(scanHandler_Found_Params_Versions), func(i int) bool {
return scanHandler_Found_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
})
if index < len(scanHandler_Found_Params_Versions) {
if scanHandler_Found_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
index--
}
expectedSize := scanHandler_Found_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.inS.Decode(decoder); err != nil {
return err
}
}
}
if err := decoder.Finish(); err != nil {
return err
}
return nil
}
func (p *ScanHandler_Proxy) Found(inS Service) (err error) {
payload := &scanHandler_Found_Params{
inS,
}
header := bindings.MessageHeader{
Type: scanHandler_Found_Name,
Flags: bindings.MessageNoFlag,
}
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
}
if err = p.router.Accept(message); err != nil {
p.Close_Proxy()
return
}
return
}
type scanHandler_Lost_Params struct {
inInstanceId []uint8
}
func (s *scanHandler_Lost_Params) Encode(encoder *bindings.Encoder) error {
encoder.StartStruct(8, 0)
if err := encoder.WritePointer(); err != nil {
return err
}
encoder.StartArray(uint32(len(s.inInstanceId)), 8)
for _, elem0 := range s.inInstanceId {
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 scanHandler_Lost_Params_Versions []bindings.DataHeader = []bindings.DataHeader{
bindings.DataHeader{16, 0},
}
func (s *scanHandler_Lost_Params) Decode(decoder *bindings.Decoder) error {
header, err := decoder.StartStruct()
if err != nil {
return err
}
index := sort.Search(len(scanHandler_Lost_Params_Versions), func(i int) bool {
return scanHandler_Lost_Params_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
})
if index < len(scanHandler_Lost_Params_Versions) {
if scanHandler_Lost_Params_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
index--
}
expectedSize := scanHandler_Lost_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 {
len0, err := decoder.StartArray(8)
if err != nil {
return err
}
s.inInstanceId = make([]uint8, len0)
for i0 := uint32(0); i0 < len0; i0++ {
value1, err := decoder.ReadUint8()
if err != nil {
return err
}
s.inInstanceId[i0] = value1
}
if err := decoder.Finish(); err != nil {
return err
}
}
}
if err := decoder.Finish(); err != nil {
return err
}
return nil
}
func (p *ScanHandler_Proxy) Lost(inInstanceId []uint8) (err error) {
payload := &scanHandler_Lost_Params{
inInstanceId,
}
header := bindings.MessageHeader{
Type: scanHandler_Lost_Name,
Flags: bindings.MessageNoFlag,
}
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
}
if err = p.router.Accept(message); err != nil {
p.Close_Proxy()
return
}
return
}
type scanHandler_Stub struct {
connector *bindings.Connector
impl ScanHandler
}
func NewScanHandlerStub(r ScanHandler_Request, impl ScanHandler, waiter bindings.AsyncWaiter) *bindings.Stub {
connector := bindings.NewConnector(r.PassMessagePipe(), waiter)
return bindings.NewStub(connector, &scanHandler_Stub{connector, impl})
}
func (s *scanHandler_Stub) Accept(message *bindings.Message) (err error) {
switch message.Header.Type {
case scanHandler_Found_Name:
if message.Header.Flags != bindings.MessageNoFlag {
return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags,
fmt.Sprintf("invalid message header flag: %v", message.Header.Flags),
}
}
var request scanHandler_Found_Params
if err := message.DecodePayload(&request); err != nil {
return err
}
err = s.impl.Found(request.inS)
if err != nil {
return
}
case scanHandler_Lost_Name:
if message.Header.Flags != bindings.MessageNoFlag {
return &bindings.ValidationError{bindings.MessageHeaderInvalidFlags,
fmt.Sprintf("invalid message header flag: %v", message.Header.Flags),
}
}
var request scanHandler_Lost_Params
if err := message.DecodePayload(&request); err != nil {
return err
}
err = s.impl.Lost(request.inInstanceId)
if err != nil {
return
}
default:
return &bindings.ValidationError{
bindings.MessageHeaderUnknownMethod,
fmt.Sprintf("unknown method %v", message.Header.Type),
}
}
return
}
type Service struct {
InstanceUuid []uint8
InterfaceName string
Attrs map[string]string
Addrs []string
}
func (s *Service) Encode(encoder *bindings.Encoder) error {
encoder.StartStruct(32, 0)
if err := encoder.WritePointer(); err != nil {
return err
}
encoder.StartArray(uint32(len(s.InstanceUuid)), 8)
for _, elem0 := range s.InstanceUuid {
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
}
if err := encoder.WriteString(s.InterfaceName); err != nil {
return err
}
if err := encoder.WritePointer(); err != nil {
return err
}
encoder.StartMap()
{
var keys0 []string
var values0 []string
for key0, value0 := range s.Attrs {
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 := encoder.WriteString(elem1); err != nil {
return err
}
}
if err := encoder.Finish(); 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.Addrs)), 64)
for _, elem0 := range s.Addrs {
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 service_Versions []bindings.DataHeader = []bindings.DataHeader{
bindings.DataHeader{40, 0},
}
func (s *Service) Decode(decoder *bindings.Decoder) error {
header, err := decoder.StartStruct()
if err != nil {
return err
}
index := sort.Search(len(service_Versions), func(i int) bool {
return service_Versions[i].ElementsOrVersion >= header.ElementsOrVersion
})
if index < len(service_Versions) {
if service_Versions[index].ElementsOrVersion > header.ElementsOrVersion {
index--
}
expectedSize := service_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 {
len0, err := decoder.StartArray(8)
if err != nil {
return err
}
s.InstanceUuid = make([]uint8, len0)
for i0 := uint32(0); i0 < len0; i0++ {
value1, err := decoder.ReadUint8()
if err != nil {
return err
}
s.InstanceUuid[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 {
value0, err := decoder.ReadString()
if err != nil {
return err
}
s.InterfaceName = 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 := 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 []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
}
values0 = 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
}
values0[i1] = value2
}
}
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]string)
for i0 := 0; i0 < len0; i0++ {
map0[keys0[i0]] = values0[i0]
}
s.Attrs = map0
}
}
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.Addrs = 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.Addrs[i0] = value1
}
}
if err := decoder.Finish(); err != nil {
return err
}
}
}
if err := decoder.Finish(); err != nil {
return err
}
return nil
}
type Error struct {
Id string
Action int32
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.WriteInt32(s.Action); 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.ReadInt32()
if err != nil {
return err
}
s.Action = 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
}