927 lines
41 KiB
Go
927 lines
41 KiB
Go
// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
|
|
// versions:
|
|
// - protoc-gen-go-grpc v1.6.2
|
|
// - protoc v7.34.1
|
|
// source: collections.proto
|
|
|
|
package waymaker_collections
|
|
|
|
import (
|
|
context "context"
|
|
grpc "google.golang.org/grpc"
|
|
codes "google.golang.org/grpc/codes"
|
|
status "google.golang.org/grpc/status"
|
|
)
|
|
|
|
// This is a compile-time assertion to ensure that this generated file
|
|
// is compatible with the grpc package it is being compiled against.
|
|
// Requires gRPC-Go v1.64.0 or later.
|
|
const _ = grpc.SupportPackageIsVersion9
|
|
|
|
const (
|
|
WaymakerCollectionsService_CreateHashStore_FullMethodName = "/waymaker.collections.WaymakerCollectionsService/CreateHashStore"
|
|
WaymakerCollectionsService_DeleteHashStore_FullMethodName = "/waymaker.collections.WaymakerCollectionsService/DeleteHashStore"
|
|
WaymakerCollectionsService_HashSet_FullMethodName = "/waymaker.collections.WaymakerCollectionsService/HashSet"
|
|
WaymakerCollectionsService_HashGet_FullMethodName = "/waymaker.collections.WaymakerCollectionsService/HashGet"
|
|
WaymakerCollectionsService_HashExists_FullMethodName = "/waymaker.collections.WaymakerCollectionsService/HashExists"
|
|
WaymakerCollectionsService_HashDelete_FullMethodName = "/waymaker.collections.WaymakerCollectionsService/HashDelete"
|
|
WaymakerCollectionsService_HashGetAll_FullMethodName = "/waymaker.collections.WaymakerCollectionsService/HashGetAll"
|
|
WaymakerCollectionsService_HashFields_FullMethodName = "/waymaker.collections.WaymakerCollectionsService/HashFields"
|
|
WaymakerCollectionsService_HashLen_FullMethodName = "/waymaker.collections.WaymakerCollectionsService/HashLen"
|
|
WaymakerCollectionsService_CreateSetStore_FullMethodName = "/waymaker.collections.WaymakerCollectionsService/CreateSetStore"
|
|
WaymakerCollectionsService_DeleteSetStore_FullMethodName = "/waymaker.collections.WaymakerCollectionsService/DeleteSetStore"
|
|
WaymakerCollectionsService_SetAdd_FullMethodName = "/waymaker.collections.WaymakerCollectionsService/SetAdd"
|
|
WaymakerCollectionsService_SetRemove_FullMethodName = "/waymaker.collections.WaymakerCollectionsService/SetRemove"
|
|
WaymakerCollectionsService_SetIsMember_FullMethodName = "/waymaker.collections.WaymakerCollectionsService/SetIsMember"
|
|
WaymakerCollectionsService_SetMembers_FullMethodName = "/waymaker.collections.WaymakerCollectionsService/SetMembers"
|
|
WaymakerCollectionsService_SetLen_FullMethodName = "/waymaker.collections.WaymakerCollectionsService/SetLen"
|
|
WaymakerCollectionsService_CreateQueue_FullMethodName = "/waymaker.collections.WaymakerCollectionsService/CreateQueue"
|
|
WaymakerCollectionsService_DeleteQueue_FullMethodName = "/waymaker.collections.WaymakerCollectionsService/DeleteQueue"
|
|
WaymakerCollectionsService_QueuePush_FullMethodName = "/waymaker.collections.WaymakerCollectionsService/QueuePush"
|
|
WaymakerCollectionsService_QueuePop_FullMethodName = "/waymaker.collections.WaymakerCollectionsService/QueuePop"
|
|
WaymakerCollectionsService_QueueRange_FullMethodName = "/waymaker.collections.WaymakerCollectionsService/QueueRange"
|
|
WaymakerCollectionsService_QueueLen_FullMethodName = "/waymaker.collections.WaymakerCollectionsService/QueueLen"
|
|
)
|
|
|
|
// WaymakerCollectionsServiceClient is the client API for WaymakerCollectionsService service.
|
|
//
|
|
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
|
|
type WaymakerCollectionsServiceClient interface {
|
|
// ----- Hash -------------------------------------------------
|
|
CreateHashStore(ctx context.Context, in *CreateHashStoreRequest, opts ...grpc.CallOption) (*CreateHashStoreResponse, error)
|
|
DeleteHashStore(ctx context.Context, in *DeleteHashStoreRequest, opts ...grpc.CallOption) (*DeleteHashStoreResponse, error)
|
|
HashSet(ctx context.Context, in *HashSetRequest, opts ...grpc.CallOption) (*HashSetResponse, error)
|
|
HashGet(ctx context.Context, in *HashGetRequest, opts ...grpc.CallOption) (*HashGetResponse, error)
|
|
HashExists(ctx context.Context, in *HashExistsRequest, opts ...grpc.CallOption) (*HashExistsResponse, error)
|
|
HashDelete(ctx context.Context, in *HashDeleteRequest, opts ...grpc.CallOption) (*HashDeleteResponse, error)
|
|
HashGetAll(ctx context.Context, in *HashGetAllRequest, opts ...grpc.CallOption) (*HashGetAllResponse, error)
|
|
HashFields(ctx context.Context, in *HashFieldsRequest, opts ...grpc.CallOption) (*HashFieldsResponse, error)
|
|
HashLen(ctx context.Context, in *HashLenRequest, opts ...grpc.CallOption) (*HashLenResponse, error)
|
|
// ----- Set --------------------------------------------------
|
|
CreateSetStore(ctx context.Context, in *CreateSetStoreRequest, opts ...grpc.CallOption) (*CreateSetStoreResponse, error)
|
|
DeleteSetStore(ctx context.Context, in *DeleteSetStoreRequest, opts ...grpc.CallOption) (*DeleteSetStoreResponse, error)
|
|
SetAdd(ctx context.Context, in *SetAddRequest, opts ...grpc.CallOption) (*SetAddResponse, error)
|
|
SetRemove(ctx context.Context, in *SetRemoveRequest, opts ...grpc.CallOption) (*SetRemoveResponse, error)
|
|
SetIsMember(ctx context.Context, in *SetIsMemberRequest, opts ...grpc.CallOption) (*SetIsMemberResponse, error)
|
|
SetMembers(ctx context.Context, in *SetMembersRequest, opts ...grpc.CallOption) (*SetMembersResponse, error)
|
|
SetLen(ctx context.Context, in *SetLenRequest, opts ...grpc.CallOption) (*SetLenResponse, error)
|
|
// ----- Queue ------------------------------------------------
|
|
CreateQueue(ctx context.Context, in *CreateQueueRequest, opts ...grpc.CallOption) (*CreateQueueResponse, error)
|
|
DeleteQueue(ctx context.Context, in *DeleteQueueRequest, opts ...grpc.CallOption) (*DeleteQueueResponse, error)
|
|
QueuePush(ctx context.Context, in *QueuePushRequest, opts ...grpc.CallOption) (*QueuePushResponse, error)
|
|
QueuePop(ctx context.Context, in *QueuePopRequest, opts ...grpc.CallOption) (*QueuePopResponse, error)
|
|
QueueRange(ctx context.Context, in *QueueRangeRequest, opts ...grpc.CallOption) (*QueueRangeResponse, error)
|
|
QueueLen(ctx context.Context, in *QueueLenRequest, opts ...grpc.CallOption) (*QueueLenResponse, error)
|
|
}
|
|
|
|
type waymakerCollectionsServiceClient struct {
|
|
cc grpc.ClientConnInterface
|
|
}
|
|
|
|
func NewWaymakerCollectionsServiceClient(cc grpc.ClientConnInterface) WaymakerCollectionsServiceClient {
|
|
return &waymakerCollectionsServiceClient{cc}
|
|
}
|
|
|
|
func (c *waymakerCollectionsServiceClient) CreateHashStore(ctx context.Context, in *CreateHashStoreRequest, opts ...grpc.CallOption) (*CreateHashStoreResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(CreateHashStoreResponse)
|
|
err := c.cc.Invoke(ctx, WaymakerCollectionsService_CreateHashStore_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *waymakerCollectionsServiceClient) DeleteHashStore(ctx context.Context, in *DeleteHashStoreRequest, opts ...grpc.CallOption) (*DeleteHashStoreResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(DeleteHashStoreResponse)
|
|
err := c.cc.Invoke(ctx, WaymakerCollectionsService_DeleteHashStore_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *waymakerCollectionsServiceClient) HashSet(ctx context.Context, in *HashSetRequest, opts ...grpc.CallOption) (*HashSetResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(HashSetResponse)
|
|
err := c.cc.Invoke(ctx, WaymakerCollectionsService_HashSet_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *waymakerCollectionsServiceClient) HashGet(ctx context.Context, in *HashGetRequest, opts ...grpc.CallOption) (*HashGetResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(HashGetResponse)
|
|
err := c.cc.Invoke(ctx, WaymakerCollectionsService_HashGet_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *waymakerCollectionsServiceClient) HashExists(ctx context.Context, in *HashExistsRequest, opts ...grpc.CallOption) (*HashExistsResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(HashExistsResponse)
|
|
err := c.cc.Invoke(ctx, WaymakerCollectionsService_HashExists_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *waymakerCollectionsServiceClient) HashDelete(ctx context.Context, in *HashDeleteRequest, opts ...grpc.CallOption) (*HashDeleteResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(HashDeleteResponse)
|
|
err := c.cc.Invoke(ctx, WaymakerCollectionsService_HashDelete_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *waymakerCollectionsServiceClient) HashGetAll(ctx context.Context, in *HashGetAllRequest, opts ...grpc.CallOption) (*HashGetAllResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(HashGetAllResponse)
|
|
err := c.cc.Invoke(ctx, WaymakerCollectionsService_HashGetAll_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *waymakerCollectionsServiceClient) HashFields(ctx context.Context, in *HashFieldsRequest, opts ...grpc.CallOption) (*HashFieldsResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(HashFieldsResponse)
|
|
err := c.cc.Invoke(ctx, WaymakerCollectionsService_HashFields_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *waymakerCollectionsServiceClient) HashLen(ctx context.Context, in *HashLenRequest, opts ...grpc.CallOption) (*HashLenResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(HashLenResponse)
|
|
err := c.cc.Invoke(ctx, WaymakerCollectionsService_HashLen_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *waymakerCollectionsServiceClient) CreateSetStore(ctx context.Context, in *CreateSetStoreRequest, opts ...grpc.CallOption) (*CreateSetStoreResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(CreateSetStoreResponse)
|
|
err := c.cc.Invoke(ctx, WaymakerCollectionsService_CreateSetStore_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *waymakerCollectionsServiceClient) DeleteSetStore(ctx context.Context, in *DeleteSetStoreRequest, opts ...grpc.CallOption) (*DeleteSetStoreResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(DeleteSetStoreResponse)
|
|
err := c.cc.Invoke(ctx, WaymakerCollectionsService_DeleteSetStore_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *waymakerCollectionsServiceClient) SetAdd(ctx context.Context, in *SetAddRequest, opts ...grpc.CallOption) (*SetAddResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(SetAddResponse)
|
|
err := c.cc.Invoke(ctx, WaymakerCollectionsService_SetAdd_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *waymakerCollectionsServiceClient) SetRemove(ctx context.Context, in *SetRemoveRequest, opts ...grpc.CallOption) (*SetRemoveResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(SetRemoveResponse)
|
|
err := c.cc.Invoke(ctx, WaymakerCollectionsService_SetRemove_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *waymakerCollectionsServiceClient) SetIsMember(ctx context.Context, in *SetIsMemberRequest, opts ...grpc.CallOption) (*SetIsMemberResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(SetIsMemberResponse)
|
|
err := c.cc.Invoke(ctx, WaymakerCollectionsService_SetIsMember_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *waymakerCollectionsServiceClient) SetMembers(ctx context.Context, in *SetMembersRequest, opts ...grpc.CallOption) (*SetMembersResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(SetMembersResponse)
|
|
err := c.cc.Invoke(ctx, WaymakerCollectionsService_SetMembers_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *waymakerCollectionsServiceClient) SetLen(ctx context.Context, in *SetLenRequest, opts ...grpc.CallOption) (*SetLenResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(SetLenResponse)
|
|
err := c.cc.Invoke(ctx, WaymakerCollectionsService_SetLen_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *waymakerCollectionsServiceClient) CreateQueue(ctx context.Context, in *CreateQueueRequest, opts ...grpc.CallOption) (*CreateQueueResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(CreateQueueResponse)
|
|
err := c.cc.Invoke(ctx, WaymakerCollectionsService_CreateQueue_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *waymakerCollectionsServiceClient) DeleteQueue(ctx context.Context, in *DeleteQueueRequest, opts ...grpc.CallOption) (*DeleteQueueResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(DeleteQueueResponse)
|
|
err := c.cc.Invoke(ctx, WaymakerCollectionsService_DeleteQueue_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *waymakerCollectionsServiceClient) QueuePush(ctx context.Context, in *QueuePushRequest, opts ...grpc.CallOption) (*QueuePushResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(QueuePushResponse)
|
|
err := c.cc.Invoke(ctx, WaymakerCollectionsService_QueuePush_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *waymakerCollectionsServiceClient) QueuePop(ctx context.Context, in *QueuePopRequest, opts ...grpc.CallOption) (*QueuePopResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(QueuePopResponse)
|
|
err := c.cc.Invoke(ctx, WaymakerCollectionsService_QueuePop_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *waymakerCollectionsServiceClient) QueueRange(ctx context.Context, in *QueueRangeRequest, opts ...grpc.CallOption) (*QueueRangeResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(QueueRangeResponse)
|
|
err := c.cc.Invoke(ctx, WaymakerCollectionsService_QueueRange_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func (c *waymakerCollectionsServiceClient) QueueLen(ctx context.Context, in *QueueLenRequest, opts ...grpc.CallOption) (*QueueLenResponse, error) {
|
|
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
|
out := new(QueueLenResponse)
|
|
err := c.cc.Invoke(ctx, WaymakerCollectionsService_QueueLen_FullMethodName, in, out, cOpts...)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
// WaymakerCollectionsServiceServer is the server API for WaymakerCollectionsService service.
|
|
// All implementations must embed UnimplementedWaymakerCollectionsServiceServer
|
|
// for forward compatibility.
|
|
type WaymakerCollectionsServiceServer interface {
|
|
// ----- Hash -------------------------------------------------
|
|
CreateHashStore(context.Context, *CreateHashStoreRequest) (*CreateHashStoreResponse, error)
|
|
DeleteHashStore(context.Context, *DeleteHashStoreRequest) (*DeleteHashStoreResponse, error)
|
|
HashSet(context.Context, *HashSetRequest) (*HashSetResponse, error)
|
|
HashGet(context.Context, *HashGetRequest) (*HashGetResponse, error)
|
|
HashExists(context.Context, *HashExistsRequest) (*HashExistsResponse, error)
|
|
HashDelete(context.Context, *HashDeleteRequest) (*HashDeleteResponse, error)
|
|
HashGetAll(context.Context, *HashGetAllRequest) (*HashGetAllResponse, error)
|
|
HashFields(context.Context, *HashFieldsRequest) (*HashFieldsResponse, error)
|
|
HashLen(context.Context, *HashLenRequest) (*HashLenResponse, error)
|
|
// ----- Set --------------------------------------------------
|
|
CreateSetStore(context.Context, *CreateSetStoreRequest) (*CreateSetStoreResponse, error)
|
|
DeleteSetStore(context.Context, *DeleteSetStoreRequest) (*DeleteSetStoreResponse, error)
|
|
SetAdd(context.Context, *SetAddRequest) (*SetAddResponse, error)
|
|
SetRemove(context.Context, *SetRemoveRequest) (*SetRemoveResponse, error)
|
|
SetIsMember(context.Context, *SetIsMemberRequest) (*SetIsMemberResponse, error)
|
|
SetMembers(context.Context, *SetMembersRequest) (*SetMembersResponse, error)
|
|
SetLen(context.Context, *SetLenRequest) (*SetLenResponse, error)
|
|
// ----- Queue ------------------------------------------------
|
|
CreateQueue(context.Context, *CreateQueueRequest) (*CreateQueueResponse, error)
|
|
DeleteQueue(context.Context, *DeleteQueueRequest) (*DeleteQueueResponse, error)
|
|
QueuePush(context.Context, *QueuePushRequest) (*QueuePushResponse, error)
|
|
QueuePop(context.Context, *QueuePopRequest) (*QueuePopResponse, error)
|
|
QueueRange(context.Context, *QueueRangeRequest) (*QueueRangeResponse, error)
|
|
QueueLen(context.Context, *QueueLenRequest) (*QueueLenResponse, error)
|
|
mustEmbedUnimplementedWaymakerCollectionsServiceServer()
|
|
}
|
|
|
|
// UnimplementedWaymakerCollectionsServiceServer must be embedded to have
|
|
// forward compatible implementations.
|
|
//
|
|
// NOTE: this should be embedded by value instead of pointer to avoid a nil
|
|
// pointer dereference when methods are called.
|
|
type UnimplementedWaymakerCollectionsServiceServer struct{}
|
|
|
|
func (UnimplementedWaymakerCollectionsServiceServer) CreateHashStore(context.Context, *CreateHashStoreRequest) (*CreateHashStoreResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method CreateHashStore not implemented")
|
|
}
|
|
func (UnimplementedWaymakerCollectionsServiceServer) DeleteHashStore(context.Context, *DeleteHashStoreRequest) (*DeleteHashStoreResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method DeleteHashStore not implemented")
|
|
}
|
|
func (UnimplementedWaymakerCollectionsServiceServer) HashSet(context.Context, *HashSetRequest) (*HashSetResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method HashSet not implemented")
|
|
}
|
|
func (UnimplementedWaymakerCollectionsServiceServer) HashGet(context.Context, *HashGetRequest) (*HashGetResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method HashGet not implemented")
|
|
}
|
|
func (UnimplementedWaymakerCollectionsServiceServer) HashExists(context.Context, *HashExistsRequest) (*HashExistsResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method HashExists not implemented")
|
|
}
|
|
func (UnimplementedWaymakerCollectionsServiceServer) HashDelete(context.Context, *HashDeleteRequest) (*HashDeleteResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method HashDelete not implemented")
|
|
}
|
|
func (UnimplementedWaymakerCollectionsServiceServer) HashGetAll(context.Context, *HashGetAllRequest) (*HashGetAllResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method HashGetAll not implemented")
|
|
}
|
|
func (UnimplementedWaymakerCollectionsServiceServer) HashFields(context.Context, *HashFieldsRequest) (*HashFieldsResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method HashFields not implemented")
|
|
}
|
|
func (UnimplementedWaymakerCollectionsServiceServer) HashLen(context.Context, *HashLenRequest) (*HashLenResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method HashLen not implemented")
|
|
}
|
|
func (UnimplementedWaymakerCollectionsServiceServer) CreateSetStore(context.Context, *CreateSetStoreRequest) (*CreateSetStoreResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method CreateSetStore not implemented")
|
|
}
|
|
func (UnimplementedWaymakerCollectionsServiceServer) DeleteSetStore(context.Context, *DeleteSetStoreRequest) (*DeleteSetStoreResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method DeleteSetStore not implemented")
|
|
}
|
|
func (UnimplementedWaymakerCollectionsServiceServer) SetAdd(context.Context, *SetAddRequest) (*SetAddResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method SetAdd not implemented")
|
|
}
|
|
func (UnimplementedWaymakerCollectionsServiceServer) SetRemove(context.Context, *SetRemoveRequest) (*SetRemoveResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method SetRemove not implemented")
|
|
}
|
|
func (UnimplementedWaymakerCollectionsServiceServer) SetIsMember(context.Context, *SetIsMemberRequest) (*SetIsMemberResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method SetIsMember not implemented")
|
|
}
|
|
func (UnimplementedWaymakerCollectionsServiceServer) SetMembers(context.Context, *SetMembersRequest) (*SetMembersResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method SetMembers not implemented")
|
|
}
|
|
func (UnimplementedWaymakerCollectionsServiceServer) SetLen(context.Context, *SetLenRequest) (*SetLenResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method SetLen not implemented")
|
|
}
|
|
func (UnimplementedWaymakerCollectionsServiceServer) CreateQueue(context.Context, *CreateQueueRequest) (*CreateQueueResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method CreateQueue not implemented")
|
|
}
|
|
func (UnimplementedWaymakerCollectionsServiceServer) DeleteQueue(context.Context, *DeleteQueueRequest) (*DeleteQueueResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method DeleteQueue not implemented")
|
|
}
|
|
func (UnimplementedWaymakerCollectionsServiceServer) QueuePush(context.Context, *QueuePushRequest) (*QueuePushResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method QueuePush not implemented")
|
|
}
|
|
func (UnimplementedWaymakerCollectionsServiceServer) QueuePop(context.Context, *QueuePopRequest) (*QueuePopResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method QueuePop not implemented")
|
|
}
|
|
func (UnimplementedWaymakerCollectionsServiceServer) QueueRange(context.Context, *QueueRangeRequest) (*QueueRangeResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method QueueRange not implemented")
|
|
}
|
|
func (UnimplementedWaymakerCollectionsServiceServer) QueueLen(context.Context, *QueueLenRequest) (*QueueLenResponse, error) {
|
|
return nil, status.Error(codes.Unimplemented, "method QueueLen not implemented")
|
|
}
|
|
func (UnimplementedWaymakerCollectionsServiceServer) mustEmbedUnimplementedWaymakerCollectionsServiceServer() {
|
|
}
|
|
func (UnimplementedWaymakerCollectionsServiceServer) testEmbeddedByValue() {}
|
|
|
|
// UnsafeWaymakerCollectionsServiceServer may be embedded to opt out of forward compatibility for this service.
|
|
// Use of this interface is not recommended, as added methods to WaymakerCollectionsServiceServer will
|
|
// result in compilation errors.
|
|
type UnsafeWaymakerCollectionsServiceServer interface {
|
|
mustEmbedUnimplementedWaymakerCollectionsServiceServer()
|
|
}
|
|
|
|
func RegisterWaymakerCollectionsServiceServer(s grpc.ServiceRegistrar, srv WaymakerCollectionsServiceServer) {
|
|
// If the following call panics, it indicates UnimplementedWaymakerCollectionsServiceServer was
|
|
// embedded by pointer and is nil. This will cause panics if an
|
|
// unimplemented method is ever invoked, so we test this at initialization
|
|
// time to prevent it from happening at runtime later due to I/O.
|
|
if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
|
|
t.testEmbeddedByValue()
|
|
}
|
|
s.RegisterService(&WaymakerCollectionsService_ServiceDesc, srv)
|
|
}
|
|
|
|
func _WaymakerCollectionsService_CreateHashStore_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(CreateHashStoreRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(WaymakerCollectionsServiceServer).CreateHashStore(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: WaymakerCollectionsService_CreateHashStore_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(WaymakerCollectionsServiceServer).CreateHashStore(ctx, req.(*CreateHashStoreRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _WaymakerCollectionsService_DeleteHashStore_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(DeleteHashStoreRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(WaymakerCollectionsServiceServer).DeleteHashStore(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: WaymakerCollectionsService_DeleteHashStore_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(WaymakerCollectionsServiceServer).DeleteHashStore(ctx, req.(*DeleteHashStoreRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _WaymakerCollectionsService_HashSet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(HashSetRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(WaymakerCollectionsServiceServer).HashSet(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: WaymakerCollectionsService_HashSet_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(WaymakerCollectionsServiceServer).HashSet(ctx, req.(*HashSetRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _WaymakerCollectionsService_HashGet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(HashGetRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(WaymakerCollectionsServiceServer).HashGet(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: WaymakerCollectionsService_HashGet_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(WaymakerCollectionsServiceServer).HashGet(ctx, req.(*HashGetRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _WaymakerCollectionsService_HashExists_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(HashExistsRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(WaymakerCollectionsServiceServer).HashExists(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: WaymakerCollectionsService_HashExists_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(WaymakerCollectionsServiceServer).HashExists(ctx, req.(*HashExistsRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _WaymakerCollectionsService_HashDelete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(HashDeleteRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(WaymakerCollectionsServiceServer).HashDelete(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: WaymakerCollectionsService_HashDelete_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(WaymakerCollectionsServiceServer).HashDelete(ctx, req.(*HashDeleteRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _WaymakerCollectionsService_HashGetAll_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(HashGetAllRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(WaymakerCollectionsServiceServer).HashGetAll(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: WaymakerCollectionsService_HashGetAll_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(WaymakerCollectionsServiceServer).HashGetAll(ctx, req.(*HashGetAllRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _WaymakerCollectionsService_HashFields_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(HashFieldsRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(WaymakerCollectionsServiceServer).HashFields(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: WaymakerCollectionsService_HashFields_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(WaymakerCollectionsServiceServer).HashFields(ctx, req.(*HashFieldsRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _WaymakerCollectionsService_HashLen_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(HashLenRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(WaymakerCollectionsServiceServer).HashLen(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: WaymakerCollectionsService_HashLen_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(WaymakerCollectionsServiceServer).HashLen(ctx, req.(*HashLenRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _WaymakerCollectionsService_CreateSetStore_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(CreateSetStoreRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(WaymakerCollectionsServiceServer).CreateSetStore(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: WaymakerCollectionsService_CreateSetStore_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(WaymakerCollectionsServiceServer).CreateSetStore(ctx, req.(*CreateSetStoreRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _WaymakerCollectionsService_DeleteSetStore_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(DeleteSetStoreRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(WaymakerCollectionsServiceServer).DeleteSetStore(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: WaymakerCollectionsService_DeleteSetStore_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(WaymakerCollectionsServiceServer).DeleteSetStore(ctx, req.(*DeleteSetStoreRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _WaymakerCollectionsService_SetAdd_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(SetAddRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(WaymakerCollectionsServiceServer).SetAdd(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: WaymakerCollectionsService_SetAdd_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(WaymakerCollectionsServiceServer).SetAdd(ctx, req.(*SetAddRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _WaymakerCollectionsService_SetRemove_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(SetRemoveRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(WaymakerCollectionsServiceServer).SetRemove(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: WaymakerCollectionsService_SetRemove_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(WaymakerCollectionsServiceServer).SetRemove(ctx, req.(*SetRemoveRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _WaymakerCollectionsService_SetIsMember_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(SetIsMemberRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(WaymakerCollectionsServiceServer).SetIsMember(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: WaymakerCollectionsService_SetIsMember_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(WaymakerCollectionsServiceServer).SetIsMember(ctx, req.(*SetIsMemberRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _WaymakerCollectionsService_SetMembers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(SetMembersRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(WaymakerCollectionsServiceServer).SetMembers(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: WaymakerCollectionsService_SetMembers_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(WaymakerCollectionsServiceServer).SetMembers(ctx, req.(*SetMembersRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _WaymakerCollectionsService_SetLen_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(SetLenRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(WaymakerCollectionsServiceServer).SetLen(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: WaymakerCollectionsService_SetLen_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(WaymakerCollectionsServiceServer).SetLen(ctx, req.(*SetLenRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _WaymakerCollectionsService_CreateQueue_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(CreateQueueRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(WaymakerCollectionsServiceServer).CreateQueue(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: WaymakerCollectionsService_CreateQueue_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(WaymakerCollectionsServiceServer).CreateQueue(ctx, req.(*CreateQueueRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _WaymakerCollectionsService_DeleteQueue_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(DeleteQueueRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(WaymakerCollectionsServiceServer).DeleteQueue(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: WaymakerCollectionsService_DeleteQueue_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(WaymakerCollectionsServiceServer).DeleteQueue(ctx, req.(*DeleteQueueRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _WaymakerCollectionsService_QueuePush_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(QueuePushRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(WaymakerCollectionsServiceServer).QueuePush(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: WaymakerCollectionsService_QueuePush_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(WaymakerCollectionsServiceServer).QueuePush(ctx, req.(*QueuePushRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _WaymakerCollectionsService_QueuePop_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(QueuePopRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(WaymakerCollectionsServiceServer).QueuePop(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: WaymakerCollectionsService_QueuePop_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(WaymakerCollectionsServiceServer).QueuePop(ctx, req.(*QueuePopRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _WaymakerCollectionsService_QueueRange_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(QueueRangeRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(WaymakerCollectionsServiceServer).QueueRange(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: WaymakerCollectionsService_QueueRange_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(WaymakerCollectionsServiceServer).QueueRange(ctx, req.(*QueueRangeRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
func _WaymakerCollectionsService_QueueLen_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
|
in := new(QueueLenRequest)
|
|
if err := dec(in); err != nil {
|
|
return nil, err
|
|
}
|
|
if interceptor == nil {
|
|
return srv.(WaymakerCollectionsServiceServer).QueueLen(ctx, in)
|
|
}
|
|
info := &grpc.UnaryServerInfo{
|
|
Server: srv,
|
|
FullMethod: WaymakerCollectionsService_QueueLen_FullMethodName,
|
|
}
|
|
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
|
return srv.(WaymakerCollectionsServiceServer).QueueLen(ctx, req.(*QueueLenRequest))
|
|
}
|
|
return interceptor(ctx, in, info, handler)
|
|
}
|
|
|
|
// WaymakerCollectionsService_ServiceDesc is the grpc.ServiceDesc for WaymakerCollectionsService service.
|
|
// It's only intended for direct use with grpc.RegisterService,
|
|
// and not to be introspected or modified (even as a copy)
|
|
var WaymakerCollectionsService_ServiceDesc = grpc.ServiceDesc{
|
|
ServiceName: "waymaker.collections.WaymakerCollectionsService",
|
|
HandlerType: (*WaymakerCollectionsServiceServer)(nil),
|
|
Methods: []grpc.MethodDesc{
|
|
{
|
|
MethodName: "CreateHashStore",
|
|
Handler: _WaymakerCollectionsService_CreateHashStore_Handler,
|
|
},
|
|
{
|
|
MethodName: "DeleteHashStore",
|
|
Handler: _WaymakerCollectionsService_DeleteHashStore_Handler,
|
|
},
|
|
{
|
|
MethodName: "HashSet",
|
|
Handler: _WaymakerCollectionsService_HashSet_Handler,
|
|
},
|
|
{
|
|
MethodName: "HashGet",
|
|
Handler: _WaymakerCollectionsService_HashGet_Handler,
|
|
},
|
|
{
|
|
MethodName: "HashExists",
|
|
Handler: _WaymakerCollectionsService_HashExists_Handler,
|
|
},
|
|
{
|
|
MethodName: "HashDelete",
|
|
Handler: _WaymakerCollectionsService_HashDelete_Handler,
|
|
},
|
|
{
|
|
MethodName: "HashGetAll",
|
|
Handler: _WaymakerCollectionsService_HashGetAll_Handler,
|
|
},
|
|
{
|
|
MethodName: "HashFields",
|
|
Handler: _WaymakerCollectionsService_HashFields_Handler,
|
|
},
|
|
{
|
|
MethodName: "HashLen",
|
|
Handler: _WaymakerCollectionsService_HashLen_Handler,
|
|
},
|
|
{
|
|
MethodName: "CreateSetStore",
|
|
Handler: _WaymakerCollectionsService_CreateSetStore_Handler,
|
|
},
|
|
{
|
|
MethodName: "DeleteSetStore",
|
|
Handler: _WaymakerCollectionsService_DeleteSetStore_Handler,
|
|
},
|
|
{
|
|
MethodName: "SetAdd",
|
|
Handler: _WaymakerCollectionsService_SetAdd_Handler,
|
|
},
|
|
{
|
|
MethodName: "SetRemove",
|
|
Handler: _WaymakerCollectionsService_SetRemove_Handler,
|
|
},
|
|
{
|
|
MethodName: "SetIsMember",
|
|
Handler: _WaymakerCollectionsService_SetIsMember_Handler,
|
|
},
|
|
{
|
|
MethodName: "SetMembers",
|
|
Handler: _WaymakerCollectionsService_SetMembers_Handler,
|
|
},
|
|
{
|
|
MethodName: "SetLen",
|
|
Handler: _WaymakerCollectionsService_SetLen_Handler,
|
|
},
|
|
{
|
|
MethodName: "CreateQueue",
|
|
Handler: _WaymakerCollectionsService_CreateQueue_Handler,
|
|
},
|
|
{
|
|
MethodName: "DeleteQueue",
|
|
Handler: _WaymakerCollectionsService_DeleteQueue_Handler,
|
|
},
|
|
{
|
|
MethodName: "QueuePush",
|
|
Handler: _WaymakerCollectionsService_QueuePush_Handler,
|
|
},
|
|
{
|
|
MethodName: "QueuePop",
|
|
Handler: _WaymakerCollectionsService_QueuePop_Handler,
|
|
},
|
|
{
|
|
MethodName: "QueueRange",
|
|
Handler: _WaymakerCollectionsService_QueueRange_Handler,
|
|
},
|
|
{
|
|
MethodName: "QueueLen",
|
|
Handler: _WaymakerCollectionsService_QueueLen_Handler,
|
|
},
|
|
},
|
|
Streams: []grpc.StreamDesc{},
|
|
Metadata: "collections.proto",
|
|
}
|