bldr/resource/resource_srpc.pb.go

Rama master · réplica de lectura del repositorio original.

// Code generated by protoc-gen-srpc. DO NOT EDIT.
// protoc-gen-srpc version: v0.52.4-0.20261024233818-0a9074172c29
// source: github.com/s4wave/spacewave/bldr/resource/resource.proto

package resource

import (
	context "context"

	srpc "github.com/aperturerobotics/starpc/srpc"
)

type SRPCResourceServiceClient interface {
	// SRPCClient returns the underlying SRPC client.
	SRPCClient() srpc.Client

	// ResourceClient starts an instance of a client for the ResourceService,
	// yielding a new client ID. The client can use that ID for future RPCs
	// accessing the Resource tree. When the streaming RPC ends, references to
	// resources opened by the client will be released.
	ResourceClient(ctx context.Context) (SRPCResourceService_ResourceClientClient, error)
	// ResourceRpc is a rpc request for an open resource handle.
	// Exposes service(s) depending on the resource type.
	// The first request selects a resource; one typed acknowledgement precedes data.
	ResourceRpc(ctx context.Context) (SRPCResourceService_ResourceRpcClient, error)
	// ResourceAttach allows a client to provide resources that server-side
	// RPC handlers can invoke via getAttachedRef(id). Session-only Init/Ack,
	// then resources registered via Add/AddAck. After Init/Ack, mux_data
	// carries yamux frames for all attached resources.
	ResourceAttach(ctx context.Context) (SRPCResourceService_ResourceAttachClient, error)
}

type srpcResourceServiceClient struct {
	cc        srpc.Client
	serviceID string
}

func NewSRPCResourceServiceClient(cc srpc.Client) SRPCResourceServiceClient {
	return &srpcResourceServiceClient{cc: cc, serviceID: SRPCResourceServiceServiceID}
}

func NewSRPCResourceServiceClientWithServiceID(cc srpc.Client, serviceID string) SRPCResourceServiceClient {
	if serviceID == "" {
		serviceID = SRPCResourceServiceServiceID
	}
	return &srpcResourceServiceClient{cc: cc, serviceID: serviceID}
}

func (c *srpcResourceServiceClient) SRPCClient() srpc.Client { return c.cc }

func (c *srpcResourceServiceClient) ResourceClient(ctx context.Context) (SRPCResourceService_ResourceClientClient, error) {
	stream, err := c.cc.NewStream(ctx, c.serviceID, "ResourceClient", nil)
	if err != nil {
		return nil, err
	}
	strm := &srpcResourceService_ResourceClientClient{stream}
	return strm, nil
}

type SRPCResourceService_ResourceClientClient interface {
	srpc.Stream
	Send(*ResourceClientRequest) error
	Recv() (*ResourceClientResponse, error)
	RecvTo(*ResourceClientResponse) error
}

type srpcResourceService_ResourceClientClient struct {
	srpc.Stream
}

func (x *srpcResourceService_ResourceClientClient) Send(m *ResourceClientRequest) error {
	if m == nil {
		return nil
	}
	return x.MsgSend(m)
}

func (x *srpcResourceService_ResourceClientClient) Recv() (*ResourceClientResponse, error) {
	m := new(ResourceClientResponse)
	if err := x.MsgRecv(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (x *srpcResourceService_ResourceClientClient) RecvTo(m *ResourceClientResponse) error {
	return x.MsgRecv(m)
}

func (c *srpcResourceServiceClient) ResourceRpc(ctx context.Context) (SRPCResourceService_ResourceRpcClient, error) {
	stream, err := c.cc.NewStream(ctx, c.serviceID, "ResourceRpc", nil)
	if err != nil {
		return nil, err
	}
	strm := &srpcResourceService_ResourceRpcClient{stream}
	return strm, nil
}

type SRPCResourceService_ResourceRpcClient interface {
	srpc.Stream
	Send(*ResourceRpcPacket) error
	Recv() (*ResourceRpcPacket, error)
	RecvTo(*ResourceRpcPacket) error
}

type srpcResourceService_ResourceRpcClient struct {
	srpc.Stream
}

func (x *srpcResourceService_ResourceRpcClient) Send(m *ResourceRpcPacket) error {
	if m == nil {
		return nil
	}
	return x.MsgSend(m)
}

func (x *srpcResourceService_ResourceRpcClient) Recv() (*ResourceRpcPacket, error) {
	m := new(ResourceRpcPacket)
	if err := x.MsgRecv(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (x *srpcResourceService_ResourceRpcClient) RecvTo(m *ResourceRpcPacket) error {
	return x.MsgRecv(m)
}

func (c *srpcResourceServiceClient) ResourceAttach(ctx context.Context) (SRPCResourceService_ResourceAttachClient, error) {
	stream, err := c.cc.NewStream(ctx, c.serviceID, "ResourceAttach", nil)
	if err != nil {
		return nil, err
	}
	strm := &srpcResourceService_ResourceAttachClient{stream}
	return strm, nil
}

type SRPCResourceService_ResourceAttachClient interface {
	srpc.Stream
	Send(*ResourceAttachRequest) error
	Recv() (*ResourceAttachResponse, error)
	RecvTo(*ResourceAttachResponse) error
}

type srpcResourceService_ResourceAttachClient struct {
	srpc.Stream
}

func (x *srpcResourceService_ResourceAttachClient) Send(m *ResourceAttachRequest) error {
	if m == nil {
		return nil
	}
	return x.MsgSend(m)
}

func (x *srpcResourceService_ResourceAttachClient) Recv() (*ResourceAttachResponse, error) {
	m := new(ResourceAttachResponse)
	if err := x.MsgRecv(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (x *srpcResourceService_ResourceAttachClient) RecvTo(m *ResourceAttachResponse) error {
	return x.MsgRecv(m)
}

type SRPCResourceServiceServer interface {
	// ResourceClient starts an instance of a client for the ResourceService,
	// yielding a new client ID. The client can use that ID for future RPCs
	// accessing the Resource tree. When the streaming RPC ends, references to
	// resources opened by the client will be released.
	ResourceClient(SRPCResourceService_ResourceClientStream) error
	// ResourceRpc is a rpc request for an open resource handle.
	// Exposes service(s) depending on the resource type.
	// The first request selects a resource; one typed acknowledgement precedes data.
	ResourceRpc(SRPCResourceService_ResourceRpcStream) error
	// ResourceAttach allows a client to provide resources that server-side
	// RPC handlers can invoke via getAttachedRef(id). Session-only Init/Ack,
	// then resources registered via Add/AddAck. After Init/Ack, mux_data
	// carries yamux frames for all attached resources.
	ResourceAttach(SRPCResourceService_ResourceAttachStream) error
}

const SRPCResourceServiceServiceID = "resource.ResourceService"

type SRPCResourceServiceHandler struct {
	serviceID string
	impl      SRPCResourceServiceServer
}

// NewSRPCResourceServiceHandler constructs a new RPC handler.
// serviceID: if empty, uses default: resource.ResourceService
func NewSRPCResourceServiceHandler(impl SRPCResourceServiceServer, serviceID string) srpc.Handler {
	if serviceID == "" {
		serviceID = SRPCResourceServiceServiceID
	}
	return &SRPCResourceServiceHandler{impl: impl, serviceID: serviceID}
}

// SRPCRegisterResourceService registers the implementation with the mux.
// Uses the default serviceID: resource.ResourceService
func SRPCRegisterResourceService(mux srpc.Mux, impl SRPCResourceServiceServer) error {
	return mux.Register(NewSRPCResourceServiceHandler(impl, ""))
}

func (d *SRPCResourceServiceHandler) GetServiceID() string { return d.serviceID }

func (SRPCResourceServiceHandler) GetMethodIDs() []string {
	return []string{
		"ResourceClient",
		"ResourceRpc",
		"ResourceAttach",
	}
}

func (d *SRPCResourceServiceHandler) InvokeMethod(
	serviceID, methodID string,
	strm srpc.Stream,
) (bool, error) {
	if serviceID != "" && serviceID != d.GetServiceID() {
		return false, nil
	}

	switch methodID {
	case "ResourceClient":
		return true, d.InvokeMethod_ResourceClient(d.impl, strm)
	case "ResourceRpc":
		return true, d.InvokeMethod_ResourceRpc(d.impl, strm)
	case "ResourceAttach":
		return true, d.InvokeMethod_ResourceAttach(d.impl, strm)
	default:
		return false, nil
	}
}

func (SRPCResourceServiceHandler) InvokeMethod_ResourceClient(impl SRPCResourceServiceServer, strm srpc.Stream) error {
	clientStrm := &srpcResourceService_ResourceClientStream{strm}
	return impl.ResourceClient(clientStrm)
}

func (SRPCResourceServiceHandler) InvokeMethod_ResourceRpc(impl SRPCResourceServiceServer, strm srpc.Stream) error {
	clientStrm := &srpcResourceService_ResourceRpcStream{strm}
	return impl.ResourceRpc(clientStrm)
}

func (SRPCResourceServiceHandler) InvokeMethod_ResourceAttach(impl SRPCResourceServiceServer, strm srpc.Stream) error {
	clientStrm := &srpcResourceService_ResourceAttachStream{strm}
	return impl.ResourceAttach(clientStrm)
}

type SRPCResourceService_ResourceClientStream interface {
	srpc.Stream
	Send(*ResourceClientResponse) error
	SendAndClose(*ResourceClientResponse) error
	Recv() (*ResourceClientRequest, error)
	RecvTo(*ResourceClientRequest) error
}

type srpcResourceService_ResourceClientStream struct {
	srpc.Stream
}

func (x *srpcResourceService_ResourceClientStream) Send(m *ResourceClientResponse) error {
	return x.MsgSend(m)
}

func (x *srpcResourceService_ResourceClientStream) SendAndClose(m *ResourceClientResponse) error {
	if m != nil {
		if err := x.MsgSend(m); err != nil {
			return err
		}
	}
	return x.CloseSend()
}

func (x *srpcResourceService_ResourceClientStream) Recv() (*ResourceClientRequest, error) {
	m := new(ResourceClientRequest)
	if err := x.MsgRecv(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (x *srpcResourceService_ResourceClientStream) RecvTo(m *ResourceClientRequest) error {
	return x.MsgRecv(m)
}

type SRPCResourceService_ResourceRpcStream interface {
	srpc.Stream
	Send(*ResourceRpcPacket) error
	SendAndClose(*ResourceRpcPacket) error
	Recv() (*ResourceRpcPacket, error)
	RecvTo(*ResourceRpcPacket) error
}

type srpcResourceService_ResourceRpcStream struct {
	srpc.Stream
}

func (x *srpcResourceService_ResourceRpcStream) Send(m *ResourceRpcPacket) error {
	return x.MsgSend(m)
}

func (x *srpcResourceService_ResourceRpcStream) SendAndClose(m *ResourceRpcPacket) error {
	if m != nil {
		if err := x.MsgSend(m); err != nil {
			return err
		}
	}
	return x.CloseSend()
}

func (x *srpcResourceService_ResourceRpcStream) Recv() (*ResourceRpcPacket, error) {
	m := new(ResourceRpcPacket)
	if err := x.MsgRecv(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (x *srpcResourceService_ResourceRpcStream) RecvTo(m *ResourceRpcPacket) error {
	return x.MsgRecv(m)
}

type SRPCResourceService_ResourceAttachStream interface {
	srpc.Stream
	Send(*ResourceAttachResponse) error
	SendAndClose(*ResourceAttachResponse) error
	Recv() (*ResourceAttachRequest, error)
	RecvTo(*ResourceAttachRequest) error
}

type srpcResourceService_ResourceAttachStream struct {
	srpc.Stream
}

func (x *srpcResourceService_ResourceAttachStream) Send(m *ResourceAttachResponse) error {
	return x.MsgSend(m)
}

func (x *srpcResourceService_ResourceAttachStream) SendAndClose(m *ResourceAttachResponse) error {
	if m != nil {
		if err := x.MsgSend(m); err != nil {
			return err
		}
	}
	return x.CloseSend()
}

func (x *srpcResourceService_ResourceAttachStream) Recv() (*ResourceAttachRequest, error) {
	m := new(ResourceAttachRequest)
	if err := x.MsgRecv(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (x *srpcResourceService_ResourceAttachStream) RecvTo(m *ResourceAttachRequest) error {
	return x.MsgRecv(m)
}