trpc.group/trpc-go/trpc-go@v1.0.3/testdata/restful/bookstore/bookstore.trpc.go

//
//
// Tencent is pleased to support the open source community by making tRPC available.
//
// Copyright (C) 2023 THL A29 Limited, a Tencent company.
// All rights reserved.
//
// If you have downloaded a copy of the tRPC source code from Tencent,
// please note that tRPC source code is licensed under the  Apache 2.0 License,
// A copy of the Apache 2.0 License is included in this file.
//
//

// Code generated by trpc-go/trpc-cmdline v2.0.13. DO NOT EDIT.
// source: bookstore.proto

package bookstore

import (
	"context"
	"fmt"

	emptypb "google.golang.org/protobuf/types/known/emptypb"
	_ "trpc.group/trpc-go/trpc-go"
	"trpc.group/trpc-go/trpc-go/client"
	"trpc.group/trpc-go/trpc-go/codec"
	_ "trpc.group/trpc-go/trpc-go/http"
	"trpc.group/trpc-go/trpc-go/restful"
	"trpc.group/trpc-go/trpc-go/server"
)

/* ************************************ Service Definition ************************************ */

// BookstoreService defines service
type BookstoreService interface {

	// ListShelves 获取所有的书柜
	ListShelves(ctx context.Context, req *emptypb.Empty) (*ListShelvesResponse, error)
	// CreateShelf 创建一个书柜
	CreateShelf(ctx context.Context, req *CreateShelfRequest) (*Shelf, error)
	// GetShelf 获取一个书柜
	GetShelf(ctx context.Context, req *GetShelfRequest) (*Shelf, error)
	// DeleteShelf 删除一个书柜
	DeleteShelf(ctx context.Context, req *DeleteShelfRequest) (*emptypb.Empty, error)
	// ListBooks 获取所有的书
	ListBooks(ctx context.Context, req *ListBooksRequest) (*ListBooksResponse, error)
	// CreateBook 创建一本书
	CreateBook(ctx context.Context, req *CreateBookRequest) (*Book, error)
	// GetBook 获取一本书
	GetBook(ctx context.Context, req *GetBookRequest) (*Book, error)
	// DeleteBook 删除一本书
	DeleteBook(ctx context.Context, req *DeleteBookRequest) (*emptypb.Empty, error)
	// UpdateBook 更新一本书
	UpdateBook(ctx context.Context, req *UpdateBookRequest) (*Book, error)

	UpdateBooks(ctx context.Context, req *UpdateBooksRequest) (*ListBooksResponse, error)
}

func BookstoreService_ListShelves_Handler(svr interface{}, ctx context.Context, f server.FilterFunc) (interface{}, error) {
	req := &emptypb.Empty{}
	filters, err := f(req)
	if err != nil {
		return nil, err
	}
	handleFunc := func(ctx context.Context, reqBody interface{}) (interface{}, error) {
		return svr.(BookstoreService).ListShelves(ctx, reqBody.(*emptypb.Empty))
	}

	var rsp interface{}
	rsp, err = filters.Filter(ctx, req, handleFunc)
	if err != nil {
		return nil, err
	}
	return rsp, nil
}

func BookstoreService_CreateShelf_Handler(svr interface{}, ctx context.Context, f server.FilterFunc) (interface{}, error) {
	req := &CreateShelfRequest{}
	filters, err := f(req)
	if err != nil {
		return nil, err
	}
	handleFunc := func(ctx context.Context, reqBody interface{}) (interface{}, error) {
		return svr.(BookstoreService).CreateShelf(ctx, reqBody.(*CreateShelfRequest))
	}

	var rsp interface{}
	rsp, err = filters.Filter(ctx, req, handleFunc)
	if err != nil {
		return nil, err
	}
	return rsp, nil
}

func BookstoreService_GetShelf_Handler(svr interface{}, ctx context.Context, f server.FilterFunc) (interface{}, error) {
	req := &GetShelfRequest{}
	filters, err := f(req)
	if err != nil {
		return nil, err
	}
	handleFunc := func(ctx context.Context, reqBody interface{}) (interface{}, error) {
		return svr.(BookstoreService).GetShelf(ctx, reqBody.(*GetShelfRequest))
	}

	var rsp interface{}
	rsp, err = filters.Filter(ctx, req, handleFunc)
	if err != nil {
		return nil, err
	}
	return rsp, nil
}

func BookstoreService_DeleteShelf_Handler(svr interface{}, ctx context.Context, f server.FilterFunc) (interface{}, error) {
	req := &DeleteShelfRequest{}
	filters, err := f(req)
	if err != nil {
		return nil, err
	}
	handleFunc := func(ctx context.Context, reqBody interface{}) (interface{}, error) {
		return svr.(BookstoreService).DeleteShelf(ctx, reqBody.(*DeleteShelfRequest))
	}

	var rsp interface{}
	rsp, err = filters.Filter(ctx, req, handleFunc)
	if err != nil {
		return nil, err
	}
	return rsp, nil
}

func BookstoreService_ListBooks_Handler(svr interface{}, ctx context.Context, f server.FilterFunc) (interface{}, error) {
	req := &ListBooksRequest{}
	filters, err := f(req)
	if err != nil {
		return nil, err
	}
	handleFunc := func(ctx context.Context, reqBody interface{}) (interface{}, error) {
		return svr.(BookstoreService).ListBooks(ctx, reqBody.(*ListBooksRequest))
	}

	var rsp interface{}
	rsp, err = filters.Filter(ctx, req, handleFunc)
	if err != nil {
		return nil, err
	}
	return rsp, nil
}

func BookstoreService_CreateBook_Handler(svr interface{}, ctx context.Context, f server.FilterFunc) (interface{}, error) {
	req := &CreateBookRequest{}
	filters, err := f(req)
	if err != nil {
		return nil, err
	}
	handleFunc := func(ctx context.Context, reqBody interface{}) (interface{}, error) {
		return svr.(BookstoreService).CreateBook(ctx, reqBody.(*CreateBookRequest))
	}

	var rsp interface{}
	rsp, err = filters.Filter(ctx, req, handleFunc)
	if err != nil {
		return nil, err
	}
	return rsp, nil
}

func BookstoreService_GetBook_Handler(svr interface{}, ctx context.Context, f server.FilterFunc) (interface{}, error) {
	req := &GetBookRequest{}
	filters, err := f(req)
	if err != nil {
		return nil, err
	}
	handleFunc := func(ctx context.Context, reqBody interface{}) (interface{}, error) {
		return svr.(BookstoreService).GetBook(ctx, reqBody.(*GetBookRequest))
	}

	var rsp interface{}
	rsp, err = filters.Filter(ctx, req, handleFunc)
	if err != nil {
		return nil, err
	}
	return rsp, nil
}

func BookstoreService_DeleteBook_Handler(svr interface{}, ctx context.Context, f server.FilterFunc) (interface{}, error) {
	req := &DeleteBookRequest{}
	filters, err := f(req)
	if err != nil {
		return nil, err
	}
	handleFunc := func(ctx context.Context, reqBody interface{}) (interface{}, error) {
		return svr.(BookstoreService).DeleteBook(ctx, reqBody.(*DeleteBookRequest))
	}

	var rsp interface{}
	rsp, err = filters.Filter(ctx, req, handleFunc)
	if err != nil {
		return nil, err
	}
	return rsp, nil
}

func BookstoreService_UpdateBook_Handler(svr interface{}, ctx context.Context, f server.FilterFunc) (interface{}, error) {
	req := &UpdateBookRequest{}
	filters, err := f(req)
	if err != nil {
		return nil, err
	}
	handleFunc := func(ctx context.Context, reqBody interface{}) (interface{}, error) {
		return svr.(BookstoreService).UpdateBook(ctx, reqBody.(*UpdateBookRequest))
	}

	var rsp interface{}
	rsp, err = filters.Filter(ctx, req, handleFunc)
	if err != nil {
		return nil, err
	}
	return rsp, nil
}

func BookstoreService_UpdateBooks_Handler(svr interface{}, ctx context.Context, f server.FilterFunc) (interface{}, error) {
	req := &UpdateBooksRequest{}
	filters, err := f(req)
	if err != nil {
		return nil, err
	}
	handleFunc := func(ctx context.Context, reqBody interface{}) (interface{}, error) {
		return svr.(BookstoreService).UpdateBooks(ctx, reqBody.(*UpdateBooksRequest))
	}

	var rsp interface{}
	rsp, err = filters.Filter(ctx, req, handleFunc)
	if err != nil {
		return nil, err
	}
	return rsp, nil
}

// responseBodyBookstoreServiceListShelvesRESTfulPath0 GET: /shelves
type responseBodyBookstoreServiceListShelvesRESTfulPath0 struct{}

func (responseBodyBookstoreServiceListShelvesRESTfulPath0) Locate(message restful.ProtoMessage) interface{} {
	x := message.(*ListShelvesResponse)
	return &x.Shelves
}

func (responseBodyBookstoreServiceListShelvesRESTfulPath0) ResponseBody() string {
	return "shelves"
}

// requestBodyBookstoreServiceCreateShelfRESTfulPath0 POST: /shelf
type requestBodyBookstoreServiceCreateShelfRESTfulPath0 struct{}

func (requestBodyBookstoreServiceCreateShelfRESTfulPath0) Locate(message restful.ProtoMessage) interface{} {
	x := message.(*CreateShelfRequest)
	return x
}

func (requestBodyBookstoreServiceCreateShelfRESTfulPath0) Body() string {
	return "*"
}

// requestBodyBookstoreServiceCreateBookRESTfulPath0 POST: /book/shelf/{shelf}
type requestBodyBookstoreServiceCreateBookRESTfulPath0 struct{}

func (requestBodyBookstoreServiceCreateBookRESTfulPath0) Locate(message restful.ProtoMessage) interface{} {
	x := message.(*CreateBookRequest)
	return &x.Book
}

func (requestBodyBookstoreServiceCreateBookRESTfulPath0) Body() string {
	return "book"
}

// requestBodyBookstoreServiceUpdateBookRESTfulPath0 PATCH: /book/shelfid/{shelf}/bookid/{book.id}
type requestBodyBookstoreServiceUpdateBookRESTfulPath0 struct{}

func (requestBodyBookstoreServiceUpdateBookRESTfulPath0) Locate(message restful.ProtoMessage) interface{} {
	x := message.(*UpdateBookRequest)
	return &x.Book
}

func (requestBodyBookstoreServiceUpdateBookRESTfulPath0) Body() string {
	return "book"
}

// requestBodyBookstoreServiceUpdateBooksRESTfulPath0 PATCH: /book/shelfid/{shelf}
type requestBodyBookstoreServiceUpdateBooksRESTfulPath0 struct{}

func (requestBodyBookstoreServiceUpdateBooksRESTfulPath0) Locate(message restful.ProtoMessage) interface{} {
	x := message.(*UpdateBooksRequest)
	return &x.Books
}

func (requestBodyBookstoreServiceUpdateBooksRESTfulPath0) Body() string {
	return "books"
}

// BookstoreServer_ServiceDesc descriptor for server.RegisterService
var BookstoreServer_ServiceDesc = server.ServiceDesc{
	ServiceName: "trpc.examples.restful.bookstore.Bookstore",
	HandlerType: ((*BookstoreService)(nil)),
	Methods: []server.Method{
		{
			Name: "/trpc.examples.restful.bookstore.Bookstore/ListShelves",
			Func: BookstoreService_ListShelves_Handler,
			Bindings: []*restful.Binding{{
				Name:  "/trpc.examples.restful.bookstore.Bookstore/ListShelves",
				Input: func() restful.ProtoMessage { return new(emptypb.Empty) },
				Filter: func(svc interface{}, ctx context.Context, reqBody interface{}) (interface{}, error) {
					return svc.(BookstoreService).ListShelves(ctx, reqBody.(*emptypb.Empty))
				},
				HTTPMethod:   "GET",
				Pattern:      restful.Enforce("/shelves"),
				Body:         nil,
				ResponseBody: responseBodyBookstoreServiceListShelvesRESTfulPath0{},
			}},
		},
		{
			Name: "/trpc.examples.restful.bookstore.Bookstore/CreateShelf",
			Func: BookstoreService_CreateShelf_Handler,
			Bindings: []*restful.Binding{{
				Name:  "/trpc.examples.restful.bookstore.Bookstore/CreateShelf",
				Input: func() restful.ProtoMessage { return new(CreateShelfRequest) },
				Filter: func(svc interface{}, ctx context.Context, reqBody interface{}) (interface{}, error) {
					return svc.(BookstoreService).CreateShelf(ctx, reqBody.(*CreateShelfRequest))
				},
				HTTPMethod:   "POST",
				Pattern:      restful.Enforce("/shelf"),
				Body:         requestBodyBookstoreServiceCreateShelfRESTfulPath0{},
				ResponseBody: nil,
			}, {
				Name:  "/trpc.examples.restful.bookstore.Bookstore/CreateShelf",
				Input: func() restful.ProtoMessage { return new(CreateShelfRequest) },
				Filter: func(svc interface{}, ctx context.Context, reqBody interface{}) (interface{}, error) {
					return svc.(BookstoreService).CreateShelf(ctx, reqBody.(*CreateShelfRequest))
				},
				HTTPMethod:   "POST",
				Pattern:      restful.Enforce("/shelf/theme/{shelf.theme}"),
				Body:         nil,
				ResponseBody: nil,
			}},
		},
		{
			Name: "/trpc.examples.restful.bookstore.Bookstore/GetShelf",
			Func: BookstoreService_GetShelf_Handler,
			Bindings: []*restful.Binding{{
				Name:  "/trpc.examples.restful.bookstore.Bookstore/GetShelf",
				Input: func() restful.ProtoMessage { return new(GetShelfRequest) },
				Filter: func(svc interface{}, ctx context.Context, reqBody interface{}) (interface{}, error) {
					return svc.(BookstoreService).GetShelf(ctx, reqBody.(*GetShelfRequest))
				},
				HTTPMethod:   "GET",
				Pattern:      restful.Enforce("/shelf/{shelf}"),
				Body:         nil,
				ResponseBody: nil,
			}},
		},
		{
			Name: "/trpc.examples.restful.bookstore.Bookstore/DeleteShelf",
			Func: BookstoreService_DeleteShelf_Handler,
			Bindings: []*restful.Binding{{
				Name:  "/trpc.examples.restful.bookstore.Bookstore/DeleteShelf",
				Input: func() restful.ProtoMessage { return new(DeleteShelfRequest) },
				Filter: func(svc interface{}, ctx context.Context, reqBody interface{}) (interface{}, error) {
					return svc.(BookstoreService).DeleteShelf(ctx, reqBody.(*DeleteShelfRequest))
				},
				HTTPMethod:   "DELETE",
				Pattern:      restful.Enforce("/shelf/{shelf}"),
				Body:         nil,
				ResponseBody: nil,
			}},
		},
		{
			Name: "/trpc.examples.restful.bookstore.Bookstore/ListBooks",
			Func: BookstoreService_ListBooks_Handler,
			Bindings: []*restful.Binding{{
				Name:  "/trpc.examples.restful.bookstore.Bookstore/ListBooks",
				Input: func() restful.ProtoMessage { return new(ListBooksRequest) },
				Filter: func(svc interface{}, ctx context.Context, reqBody interface{}) (interface{}, error) {
					return svc.(BookstoreService).ListBooks(ctx, reqBody.(*ListBooksRequest))
				},
				HTTPMethod:   "GET",
				Pattern:      restful.Enforce("/books/shelf/{shelf}"),
				Body:         nil,
				ResponseBody: nil,
			}},
		},
		{
			Name: "/trpc.examples.restful.bookstore.Bookstore/CreateBook",
			Func: BookstoreService_CreateBook_Handler,
			Bindings: []*restful.Binding{{
				Name:  "/trpc.examples.restful.bookstore.Bookstore/CreateBook",
				Input: func() restful.ProtoMessage { return new(CreateBookRequest) },
				Filter: func(svc interface{}, ctx context.Context, reqBody interface{}) (interface{}, error) {
					return svc.(BookstoreService).CreateBook(ctx, reqBody.(*CreateBookRequest))
				},
				HTTPMethod:   "POST",
				Pattern:      restful.Enforce("/book/shelf/{shelf}"),
				Body:         requestBodyBookstoreServiceCreateBookRESTfulPath0{},
				ResponseBody: nil,
			}},
		},
		{
			Name: "/trpc.examples.restful.bookstore.Bookstore/GetBook",
			Func: BookstoreService_GetBook_Handler,
			Bindings: []*restful.Binding{{
				Name:  "/trpc.examples.restful.bookstore.Bookstore/GetBook",
				Input: func() restful.ProtoMessage { return new(GetBookRequest) },
				Filter: func(svc interface{}, ctx context.Context, reqBody interface{}) (interface{}, error) {
					return svc.(BookstoreService).GetBook(ctx, reqBody.(*GetBookRequest))
				},
				HTTPMethod:   "GET",
				Pattern:      restful.Enforce("/book/shelfid/{shelf}/bookid/{book}"),
				Body:         nil,
				ResponseBody: nil,
			}},
		},
		{
			Name: "/trpc.examples.restful.bookstore.Bookstore/DeleteBook",
			Func: BookstoreService_DeleteBook_Handler,
			Bindings: []*restful.Binding{{
				Name:  "/trpc.examples.restful.bookstore.Bookstore/DeleteBook",
				Input: func() restful.ProtoMessage { return new(DeleteBookRequest) },
				Filter: func(svc interface{}, ctx context.Context, reqBody interface{}) (interface{}, error) {
					return svc.(BookstoreService).DeleteBook(ctx, reqBody.(*DeleteBookRequest))
				},
				HTTPMethod:   "DELETE",
				Pattern:      restful.Enforce("/book/shelfid/{shelf}/bookid/{book}"),
				Body:         nil,
				ResponseBody: nil,
			}},
		},
		{
			Name: "/trpc.examples.restful.bookstore.Bookstore/UpdateBook",
			Func: BookstoreService_UpdateBook_Handler,
			Bindings: []*restful.Binding{{
				Name:  "/trpc.examples.restful.bookstore.Bookstore/UpdateBook",
				Input: func() restful.ProtoMessage { return new(UpdateBookRequest) },
				Filter: func(svc interface{}, ctx context.Context, reqBody interface{}) (interface{}, error) {
					return svc.(BookstoreService).UpdateBook(ctx, reqBody.(*UpdateBookRequest))
				},
				HTTPMethod:   "PATCH",
				Pattern:      restful.Enforce("/book/shelfid/{shelf}/bookid/{book.id}"),
				Body:         requestBodyBookstoreServiceUpdateBookRESTfulPath0{},
				ResponseBody: nil,
			}},
		},
		{
			Name: "/trpc.examples.restful.bookstore.Bookstore/UpdateBooks",
			Func: BookstoreService_UpdateBooks_Handler,
			Bindings: []*restful.Binding{{
				Name:  "/trpc.examples.restful.bookstore.Bookstore/UpdateBooks",
				Input: func() restful.ProtoMessage { return new(UpdateBooksRequest) },
				Filter: func(svc interface{}, ctx context.Context, reqBody interface{}) (interface{}, error) {
					return svc.(BookstoreService).UpdateBooks(ctx, reqBody.(*UpdateBooksRequest))
				},
				HTTPMethod:   "PATCH",
				Pattern:      restful.Enforce("/book/shelfid/{shelf}"),
				Body:         requestBodyBookstoreServiceUpdateBooksRESTfulPath0{},
				ResponseBody: nil,
			}},
		},
	},
}

// RegisterBookstoreService register service
func RegisterBookstoreService(s server.Service, svr BookstoreService) {
	if err := s.Register(&BookstoreServer_ServiceDesc, svr); err != nil {
		panic(fmt.Sprintf("Bookstore register error:%v", err))
	}
}

/* ************************************ Client Definition ************************************ */

// BookstoreClientProxy defines service client proxy
type BookstoreClientProxy interface { // ListShelves 获取所有的书柜
	ListShelves(ctx context.Context, req *emptypb.Empty, opts ...client.Option) (rsp *ListShelvesResponse, err error) // CreateShelf 创建一个书柜
	CreateShelf(ctx context.Context, req *CreateShelfRequest, opts ...client.Option) (rsp *Shelf, err error)          // GetShelf 获取一个书柜
	GetShelf(ctx context.Context, req *GetShelfRequest, opts ...client.Option) (rsp *Shelf, err error)                // DeleteShelf 删除一个书柜
	DeleteShelf(ctx context.Context, req *DeleteShelfRequest, opts ...client.Option) (rsp *emptypb.Empty, err error)  // ListBooks 获取所有的书
	ListBooks(ctx context.Context, req *ListBooksRequest, opts ...client.Option) (rsp *ListBooksResponse, err error)  // CreateBook 创建一本书
	CreateBook(ctx context.Context, req *CreateBookRequest, opts ...client.Option) (rsp *Book, err error)             // GetBook 获取一本书
	GetBook(ctx context.Context, req *GetBookRequest, opts ...client.Option) (rsp *Book, err error)                   // DeleteBook 删除一本书
	DeleteBook(ctx context.Context, req *DeleteBookRequest, opts ...client.Option) (rsp *emptypb.Empty, err error)    // UpdateBook 更新一本书
	UpdateBook(ctx context.Context, req *UpdateBookRequest, opts ...client.Option) (rsp *Book, err error)
	UpdateBooks(ctx context.Context, req *UpdateBooksRequest, opts ...client.Option) (rsp *ListBooksResponse, err error)
}

type BookstoreClientProxyImpl struct {
	client client.Client
	opts   []client.Option
}

var NewBookstoreClientProxy = func(opts ...client.Option) BookstoreClientProxy {
	return &BookstoreClientProxyImpl{client: client.DefaultClient, opts: opts}
}

func (c *BookstoreClientProxyImpl) ListShelves(ctx context.Context, req *emptypb.Empty, opts ...client.Option) (*ListShelvesResponse, error) {
	ctx, msg := codec.WithCloneMessage(ctx)
	defer codec.PutBackMessage(msg)
	msg.WithClientRPCName("/trpc.examples.restful.bookstore.Bookstore/ListShelves")
	msg.WithCalleeServiceName(BookstoreServer_ServiceDesc.ServiceName)
	msg.WithCalleeApp("")
	msg.WithCalleeServer("")
	msg.WithCalleeService("Bookstore")
	msg.WithCalleeMethod("ListShelves")
	msg.WithSerializationType(codec.SerializationTypePB)
	callopts := make([]client.Option, 0, len(c.opts)+len(opts))
	callopts = append(callopts, c.opts...)
	callopts = append(callopts, opts...)
	rsp := &ListShelvesResponse{}
	if err := c.client.Invoke(ctx, req, rsp, callopts...); err != nil {
		return nil, err
	}
	return rsp, nil
}

func (c *BookstoreClientProxyImpl) CreateShelf(ctx context.Context, req *CreateShelfRequest, opts ...client.Option) (*Shelf, error) {
	ctx, msg := codec.WithCloneMessage(ctx)
	defer codec.PutBackMessage(msg)
	msg.WithClientRPCName("/trpc.examples.restful.bookstore.Bookstore/CreateShelf")
	msg.WithCalleeServiceName(BookstoreServer_ServiceDesc.ServiceName)
	msg.WithCalleeApp("")
	msg.WithCalleeServer("")
	msg.WithCalleeService("Bookstore")
	msg.WithCalleeMethod("CreateShelf")
	msg.WithSerializationType(codec.SerializationTypePB)
	callopts := make([]client.Option, 0, len(c.opts)+len(opts))
	callopts = append(callopts, c.opts...)
	callopts = append(callopts, opts...)
	rsp := &Shelf{}
	if err := c.client.Invoke(ctx, req, rsp, callopts...); err != nil {
		return nil, err
	}
	return rsp, nil
}

func (c *BookstoreClientProxyImpl) GetShelf(ctx context.Context, req *GetShelfRequest, opts ...client.Option) (*Shelf, error) {
	ctx, msg := codec.WithCloneMessage(ctx)
	defer codec.PutBackMessage(msg)
	msg.WithClientRPCName("/trpc.examples.restful.bookstore.Bookstore/GetShelf")
	msg.WithCalleeServiceName(BookstoreServer_ServiceDesc.ServiceName)
	msg.WithCalleeApp("")
	msg.WithCalleeServer("")
	msg.WithCalleeService("Bookstore")
	msg.WithCalleeMethod("GetShelf")
	msg.WithSerializationType(codec.SerializationTypePB)
	callopts := make([]client.Option, 0, len(c.opts)+len(opts))
	callopts = append(callopts, c.opts...)
	callopts = append(callopts, opts...)
	rsp := &Shelf{}
	if err := c.client.Invoke(ctx, req, rsp, callopts...); err != nil {
		return nil, err
	}
	return rsp, nil
}

func (c *BookstoreClientProxyImpl) DeleteShelf(ctx context.Context, req *DeleteShelfRequest, opts ...client.Option) (*emptypb.Empty, error) {
	ctx, msg := codec.WithCloneMessage(ctx)
	defer codec.PutBackMessage(msg)
	msg.WithClientRPCName("/trpc.examples.restful.bookstore.Bookstore/DeleteShelf")
	msg.WithCalleeServiceName(BookstoreServer_ServiceDesc.ServiceName)
	msg.WithCalleeApp("")
	msg.WithCalleeServer("")
	msg.WithCalleeService("Bookstore")
	msg.WithCalleeMethod("DeleteShelf")
	msg.WithSerializationType(codec.SerializationTypePB)
	callopts := make([]client.Option, 0, len(c.opts)+len(opts))
	callopts = append(callopts, c.opts...)
	callopts = append(callopts, opts...)
	rsp := &emptypb.Empty{}
	if err := c.client.Invoke(ctx, req, rsp, callopts...); err != nil {
		return nil, err
	}
	return rsp, nil
}

func (c *BookstoreClientProxyImpl) ListBooks(ctx context.Context, req *ListBooksRequest, opts ...client.Option) (*ListBooksResponse, error) {
	ctx, msg := codec.WithCloneMessage(ctx)
	defer codec.PutBackMessage(msg)
	msg.WithClientRPCName("/trpc.examples.restful.bookstore.Bookstore/ListBooks")
	msg.WithCalleeServiceName(BookstoreServer_ServiceDesc.ServiceName)
	msg.WithCalleeApp("")
	msg.WithCalleeServer("")
	msg.WithCalleeService("Bookstore")
	msg.WithCalleeMethod("ListBooks")
	msg.WithSerializationType(codec.SerializationTypePB)
	callopts := make([]client.Option, 0, len(c.opts)+len(opts))
	callopts = append(callopts, c.opts...)
	callopts = append(callopts, opts...)
	rsp := &ListBooksResponse{}
	if err := c.client.Invoke(ctx, req, rsp, callopts...); err != nil {
		return nil, err
	}
	return rsp, nil
}

func (c *BookstoreClientProxyImpl) CreateBook(ctx context.Context, req *CreateBookRequest, opts ...client.Option) (*Book, error) {
	ctx, msg := codec.WithCloneMessage(ctx)
	defer codec.PutBackMessage(msg)
	msg.WithClientRPCName("/trpc.examples.restful.bookstore.Bookstore/CreateBook")
	msg.WithCalleeServiceName(BookstoreServer_ServiceDesc.ServiceName)
	msg.WithCalleeApp("")
	msg.WithCalleeServer("")
	msg.WithCalleeService("Bookstore")
	msg.WithCalleeMethod("CreateBook")
	msg.WithSerializationType(codec.SerializationTypePB)
	callopts := make([]client.Option, 0, len(c.opts)+len(opts))
	callopts = append(callopts, c.opts...)
	callopts = append(callopts, opts...)
	rsp := &Book{}
	if err := c.client.Invoke(ctx, req, rsp, callopts...); err != nil {
		return nil, err
	}
	return rsp, nil
}

func (c *BookstoreClientProxyImpl) GetBook(ctx context.Context, req *GetBookRequest, opts ...client.Option) (*Book, error) {
	ctx, msg := codec.WithCloneMessage(ctx)
	defer codec.PutBackMessage(msg)
	msg.WithClientRPCName("/trpc.examples.restful.bookstore.Bookstore/GetBook")
	msg.WithCalleeServiceName(BookstoreServer_ServiceDesc.ServiceName)
	msg.WithCalleeApp("")
	msg.WithCalleeServer("")
	msg.WithCalleeService("Bookstore")
	msg.WithCalleeMethod("GetBook")
	msg.WithSerializationType(codec.SerializationTypePB)
	callopts := make([]client.Option, 0, len(c.opts)+len(opts))
	callopts = append(callopts, c.opts...)
	callopts = append(callopts, opts...)
	rsp := &Book{}
	if err := c.client.Invoke(ctx, req, rsp, callopts...); err != nil {
		return nil, err
	}
	return rsp, nil
}

func (c *BookstoreClientProxyImpl) DeleteBook(ctx context.Context, req *DeleteBookRequest, opts ...client.Option) (*emptypb.Empty, error) {
	ctx, msg := codec.WithCloneMessage(ctx)
	defer codec.PutBackMessage(msg)
	msg.WithClientRPCName("/trpc.examples.restful.bookstore.Bookstore/DeleteBook")
	msg.WithCalleeServiceName(BookstoreServer_ServiceDesc.ServiceName)
	msg.WithCalleeApp("")
	msg.WithCalleeServer("")
	msg.WithCalleeService("Bookstore")
	msg.WithCalleeMethod("DeleteBook")
	msg.WithSerializationType(codec.SerializationTypePB)
	callopts := make([]client.Option, 0, len(c.opts)+len(opts))
	callopts = append(callopts, c.opts...)
	callopts = append(callopts, opts...)
	rsp := &emptypb.Empty{}
	if err := c.client.Invoke(ctx, req, rsp, callopts...); err != nil {
		return nil, err
	}
	return rsp, nil
}

func (c *BookstoreClientProxyImpl) UpdateBook(ctx context.Context, req *UpdateBookRequest, opts ...client.Option) (*Book, error) {
	ctx, msg := codec.WithCloneMessage(ctx)
	defer codec.PutBackMessage(msg)
	msg.WithClientRPCName("/trpc.examples.restful.bookstore.Bookstore/UpdateBook")
	msg.WithCalleeServiceName(BookstoreServer_ServiceDesc.ServiceName)
	msg.WithCalleeApp("")
	msg.WithCalleeServer("")
	msg.WithCalleeService("Bookstore")
	msg.WithCalleeMethod("UpdateBook")
	msg.WithSerializationType(codec.SerializationTypePB)
	callopts := make([]client.Option, 0, len(c.opts)+len(opts))
	callopts = append(callopts, c.opts...)
	callopts = append(callopts, opts...)
	rsp := &Book{}
	if err := c.client.Invoke(ctx, req, rsp, callopts...); err != nil {
		return nil, err
	}
	return rsp, nil
}

func (c *BookstoreClientProxyImpl) UpdateBooks(ctx context.Context, req *UpdateBooksRequest, opts ...client.Option) (*ListBooksResponse, error) {
	ctx, msg := codec.WithCloneMessage(ctx)
	defer codec.PutBackMessage(msg)
	msg.WithClientRPCName("/trpc.examples.restful.bookstore.Bookstore/UpdateBooks")
	msg.WithCalleeServiceName(BookstoreServer_ServiceDesc.ServiceName)
	msg.WithCalleeApp("")
	msg.WithCalleeServer("")
	msg.WithCalleeService("Bookstore")
	msg.WithCalleeMethod("UpdateBooks")
	msg.WithSerializationType(codec.SerializationTypePB)
	callopts := make([]client.Option, 0, len(c.opts)+len(opts))
	callopts = append(callopts, c.opts...)
	callopts = append(callopts, opts...)
	rsp := &ListBooksResponse{}
	if err := c.client.Invoke(ctx, req, rsp, callopts...); err != nil {
		return nil, err
	}
	return rsp, nil
}