vendor/google.golang.org/genproto/googleapis/bigtable/v1/bigtable_service.pb.go

   1 // Code generated by protoc-gen-go. DO NOT EDIT.
   2 // source: google/bigtable/v1/bigtable_service.proto
   3
   4 package bigtable
   5
   6 import proto "github.com/golang/protobuf/proto"
   7 import fmt "fmt"
   8 import math "math"
   9 import _ "google.golang.org/genproto/googleapis/api/annotations"
  10 import google_protobuf2 "github.com/golang/protobuf/ptypes/empty"
  11
  12 import (
  13         context "golang.org/x/net/context"
  14         grpc "google.golang.org/grpc"
  15 )
  16
  17 // Reference imports to suppress errors if they are not otherwise used.
  18 var _ = proto.Marshal
  19 var _ = fmt.Errorf
  20 var _ = math.Inf
  21
  22 // Reference imports to suppress errors if they are not otherwise used.
  23 var _ context.Context
  24 var _ grpc.ClientConn
  25
  26 // This is a compile-time assertion to ensure that this generated file
  27 // is compatible with the grpc package it is being compiled against.
  28 const _ = grpc.SupportPackageIsVersion4
  29
  30 // Client API for BigtableService service
  31
  32 type BigtableServiceClient interface {
  33         // Streams back the contents of all requested rows, optionally applying
  34         // the same Reader filter to each. Depending on their size, rows may be
  35         // broken up across multiple responses, but atomicity of each row will still
  36         // be preserved.
  37         ReadRows(ctx context.Context, in *ReadRowsRequest, opts ...grpc.CallOption) (BigtableService_ReadRowsClient, error)
  38         // Returns a sample of row keys in the table. The returned row keys will
  39         // delimit contiguous sections of the table of approximately equal size,
  40         // which can be used to break up the data for distributed tasks like
  41         // mapreduces.
  42         SampleRowKeys(ctx context.Context, in *SampleRowKeysRequest, opts ...grpc.CallOption) (BigtableService_SampleRowKeysClient, error)
  43         // Mutates a row atomically. Cells already present in the row are left
  44         // unchanged unless explicitly changed by 'mutation'.
  45         MutateRow(ctx context.Context, in *MutateRowRequest, opts ...grpc.CallOption) (*google_protobuf2.Empty, error)
  46         // Mutates multiple rows in a batch. Each individual row is mutated
  47         // atomically as in MutateRow, but the entire batch is not executed
  48         // atomically.
  49         MutateRows(ctx context.Context, in *MutateRowsRequest, opts ...grpc.CallOption) (*MutateRowsResponse, error)
  50         // Mutates a row atomically based on the output of a predicate Reader filter.
  51         CheckAndMutateRow(ctx context.Context, in *CheckAndMutateRowRequest, opts ...grpc.CallOption) (*CheckAndMutateRowResponse, error)
  52         // Modifies a row atomically, reading the latest existing timestamp/value from
  53         // the specified columns and writing a new value at
  54         // max(existing timestamp, current server time) based on pre-defined
  55         // read/modify/write rules. Returns the new contents of all modified cells.
  56         ReadModifyWriteRow(ctx context.Context, in *ReadModifyWriteRowRequest, opts ...grpc.CallOption) (*Row, error)
  57 }
  58
  59 type bigtableServiceClient struct {
  60         cc *grpc.ClientConn
  61 }
  62
  63 func NewBigtableServiceClient(cc *grpc.ClientConn) BigtableServiceClient {
  64         return &bigtableServiceClient{cc}
  65 }
  66
  67 func (c *bigtableServiceClient) ReadRows(ctx context.Context, in *ReadRowsRequest, opts ...grpc.CallOption) (BigtableService_ReadRowsClient, error) {
  68         stream, err := grpc.NewClientStream(ctx, &_BigtableService_serviceDesc.Streams[0], c.cc, "/google.bigtable.v1.BigtableService/ReadRows", opts...)
  69         if err != nil {
  70                 return nil, err
  71         }
  72         x := &bigtableServiceReadRowsClient{stream}
  73         if err := x.ClientStream.SendMsg(in); err != nil {
  74                 return nil, err
  75         }
  76         if err := x.ClientStream.CloseSend(); err != nil {
  77                 return nil, err
  78         }
  79         return x, nil
  80 }
  81
  82 type BigtableService_ReadRowsClient interface {
  83         Recv() (*ReadRowsResponse, error)
  84         grpc.ClientStream
  85 }
  86
  87 type bigtableServiceReadRowsClient struct {
  88         grpc.ClientStream
  89 }
  90
  91 func (x *bigtableServiceReadRowsClient) Recv() (*ReadRowsResponse, error) {
  92         m := new(ReadRowsResponse)
  93         if err := x.ClientStream.RecvMsg(m); err != nil {
  94                 return nil, err
  95         }
  96         return m, nil
  97 }
  98
  99 func (c *bigtableServiceClient) SampleRowKeys(ctx context.Context, in *SampleRowKeysRequest, opts ...grpc.CallOption) (BigtableService_SampleRowKeysClient, error) {
 100         stream, err := grpc.NewClientStream(ctx, &_BigtableService_serviceDesc.Streams[1], c.cc, "/google.bigtable.v1.BigtableService/SampleRowKeys", opts...)
 101         if err != nil {
 102                 return nil, err
 103         }
 104         x := &bigtableServiceSampleRowKeysClient{stream}
 105         if err := x.ClientStream.SendMsg(in); err != nil {
 106                 return nil, err
 107         }
 108         if err := x.ClientStream.CloseSend(); err != nil {
 109                 return nil, err
 110         }
 111         return x, nil
 112 }
 113
 114 type BigtableService_SampleRowKeysClient interface {
 115         Recv() (*SampleRowKeysResponse, error)
 116         grpc.ClientStream
 117 }
 118
 119 type bigtableServiceSampleRowKeysClient struct {
 120         grpc.ClientStream
 121 }
 122
 123 func (x *bigtableServiceSampleRowKeysClient) Recv() (*SampleRowKeysResponse, error) {
 124         m := new(SampleRowKeysResponse)
 125         if err := x.ClientStream.RecvMsg(m); err != nil {
 126                 return nil, err
 127         }
 128         return m, nil
 129 }
 130
 131 func (c *bigtableServiceClient) MutateRow(ctx context.Context, in *MutateRowRequest, opts ...grpc.CallOption) (*google_protobuf2.Empty, error) {
 132         out := new(google_protobuf2.Empty)
 133         err := grpc.Invoke(ctx, "/google.bigtable.v1.BigtableService/MutateRow", in, out, c.cc, opts...)
 134         if err != nil {
 135                 return nil, err
 136         }
 137         return out, nil
 138 }
 139
 140 func (c *bigtableServiceClient) MutateRows(ctx context.Context, in *MutateRowsRequest, opts ...grpc.CallOption) (*MutateRowsResponse, error) {
 141         out := new(MutateRowsResponse)
 142         err := grpc.Invoke(ctx, "/google.bigtable.v1.BigtableService/MutateRows", in, out, c.cc, opts...)
 143         if err != nil {
 144                 return nil, err
 145         }
 146         return out, nil
 147 }
 148
 149 func (c *bigtableServiceClient) CheckAndMutateRow(ctx context.Context, in *CheckAndMutateRowRequest, opts ...grpc.CallOption) (*CheckAndMutateRowResponse, error) {
 150         out := new(CheckAndMutateRowResponse)
 151         err := grpc.Invoke(ctx, "/google.bigtable.v1.BigtableService/CheckAndMutateRow", in, out, c.cc, opts...)
 152         if err != nil {
 153                 return nil, err
 154         }
 155         return out, nil
 156 }
 157
 158 func (c *bigtableServiceClient) ReadModifyWriteRow(ctx context.Context, in *ReadModifyWriteRowRequest, opts ...grpc.CallOption) (*Row, error) {
 159         out := new(Row)
 160         err := grpc.Invoke(ctx, "/google.bigtable.v1.BigtableService/ReadModifyWriteRow", in, out, c.cc, opts...)
 161         if err != nil {
 162                 return nil, err
 163         }
 164         return out, nil
 165 }
 166
 167 // Server API for BigtableService service
 168
 169 type BigtableServiceServer interface {
 170         // Streams back the contents of all requested rows, optionally applying
 171         // the same Reader filter to each. Depending on their size, rows may be
 172         // broken up across multiple responses, but atomicity of each row will still
 173         // be preserved.
 174         ReadRows(*ReadRowsRequest, BigtableService_ReadRowsServer) error
 175         // Returns a sample of row keys in the table. The returned row keys will
 176         // delimit contiguous sections of the table of approximately equal size,
 177         // which can be used to break up the data for distributed tasks like
 178         // mapreduces.
 179         SampleRowKeys(*SampleRowKeysRequest, BigtableService_SampleRowKeysServer) error
 180         // Mutates a row atomically. Cells already present in the row are left
 181         // unchanged unless explicitly changed by 'mutation'.
 182         MutateRow(context.Context, *MutateRowRequest) (*google_protobuf2.Empty, error)
 183         // Mutates multiple rows in a batch. Each individual row is mutated
 184         // atomically as in MutateRow, but the entire batch is not executed
 185         // atomically.
 186         MutateRows(context.Context, *MutateRowsRequest) (*MutateRowsResponse, error)
 187         // Mutates a row atomically based on the output of a predicate Reader filter.
 188         CheckAndMutateRow(context.Context, *CheckAndMutateRowRequest) (*CheckAndMutateRowResponse, error)
 189         // Modifies a row atomically, reading the latest existing timestamp/value from
 190         // the specified columns and writing a new value at
 191         // max(existing timestamp, current server time) based on pre-defined
 192         // read/modify/write rules. Returns the new contents of all modified cells.
 193         ReadModifyWriteRow(context.Context, *ReadModifyWriteRowRequest) (*Row, error)
 194 }
 195
 196 func RegisterBigtableServiceServer(s *grpc.Server, srv BigtableServiceServer) {
 197         s.RegisterService(&_BigtableService_serviceDesc, srv)
 198 }
 199
 200 func _BigtableService_ReadRows_Handler(srv interface{}, stream grpc.ServerStream) error {
 201         m := new(ReadRowsRequest)
 202         if err := stream.RecvMsg(m); err != nil {
 203                 return err
 204         }
 205         return srv.(BigtableServiceServer).ReadRows(m, &bigtableServiceReadRowsServer{stream})
 206 }
 207
 208 type BigtableService_ReadRowsServer interface {
 209         Send(*ReadRowsResponse) error
 210         grpc.ServerStream
 211 }
 212
 213 type bigtableServiceReadRowsServer struct {
 214         grpc.ServerStream
 215 }
 216
 217 func (x *bigtableServiceReadRowsServer) Send(m *ReadRowsResponse) error {
 218         return x.ServerStream.SendMsg(m)
 219 }
 220
 221 func _BigtableService_SampleRowKeys_Handler(srv interface{}, stream grpc.ServerStream) error {
 222         m := new(SampleRowKeysRequest)
 223         if err := stream.RecvMsg(m); err != nil {
 224                 return err
 225         }
 226         return srv.(BigtableServiceServer).SampleRowKeys(m, &bigtableServiceSampleRowKeysServer{stream})
 227 }
 228
 229 type BigtableService_SampleRowKeysServer interface {
 230         Send(*SampleRowKeysResponse) error
 231         grpc.ServerStream
 232 }
 233
 234 type bigtableServiceSampleRowKeysServer struct {
 235         grpc.ServerStream
 236 }
 237
 238 func (x *bigtableServiceSampleRowKeysServer) Send(m *SampleRowKeysResponse) error {
 239         return x.ServerStream.SendMsg(m)
 240 }
 241
 242 func _BigtableService_MutateRow_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 243         in := new(MutateRowRequest)
 244         if err := dec(in); err != nil {
 245                 return nil, err
 246         }
 247         if interceptor == nil {
 248                 return srv.(BigtableServiceServer).MutateRow(ctx, in)
 249         }
 250         info := &grpc.UnaryServerInfo{
 251                 Server:     srv,
 252                 FullMethod: "/google.bigtable.v1.BigtableService/MutateRow",
 253         }
 254         handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 255                 return srv.(BigtableServiceServer).MutateRow(ctx, req.(*MutateRowRequest))
 256         }
 257         return interceptor(ctx, in, info, handler)
 258 }
 259
 260 func _BigtableService_MutateRows_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 261         in := new(MutateRowsRequest)
 262         if err := dec(in); err != nil {
 263                 return nil, err
 264         }
 265         if interceptor == nil {
 266                 return srv.(BigtableServiceServer).MutateRows(ctx, in)
 267         }
 268         info := &grpc.UnaryServerInfo{
 269                 Server:     srv,
 270                 FullMethod: "/google.bigtable.v1.BigtableService/MutateRows",
 271         }
 272         handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 273                 return srv.(BigtableServiceServer).MutateRows(ctx, req.(*MutateRowsRequest))
 274         }
 275         return interceptor(ctx, in, info, handler)
 276 }
 277
 278 func _BigtableService_CheckAndMutateRow_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 279         in := new(CheckAndMutateRowRequest)
 280         if err := dec(in); err != nil {
 281                 return nil, err
 282         }
 283         if interceptor == nil {
 284                 return srv.(BigtableServiceServer).CheckAndMutateRow(ctx, in)
 285         }
 286         info := &grpc.UnaryServerInfo{
 287                 Server:     srv,
 288                 FullMethod: "/google.bigtable.v1.BigtableService/CheckAndMutateRow",
 289         }
 290         handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 291                 return srv.(BigtableServiceServer).CheckAndMutateRow(ctx, req.(*CheckAndMutateRowRequest))
 292         }
 293         return interceptor(ctx, in, info, handler)
 294 }
 295
 296 func _BigtableService_ReadModifyWriteRow_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 297         in := new(ReadModifyWriteRowRequest)
 298         if err := dec(in); err != nil {
 299                 return nil, err
 300         }
 301         if interceptor == nil {
 302                 return srv.(BigtableServiceServer).ReadModifyWriteRow(ctx, in)
 303         }
 304         info := &grpc.UnaryServerInfo{
 305                 Server:     srv,
 306                 FullMethod: "/google.bigtable.v1.BigtableService/ReadModifyWriteRow",
 307         }
 308         handler := func(ctx context.Context, req interface{}) (interface{}, error) {
 309                 return srv.(BigtableServiceServer).ReadModifyWriteRow(ctx, req.(*ReadModifyWriteRowRequest))
 310         }
 311         return interceptor(ctx, in, info, handler)
 312 }
 313
 314 var _BigtableService_serviceDesc = grpc.ServiceDesc{
 315         ServiceName: "google.bigtable.v1.BigtableService",
 316         HandlerType: (*BigtableServiceServer)(nil),
 317         Methods: []grpc.MethodDesc{
 318                 {
 319                         MethodName: "MutateRow",
 320                         Handler:    _BigtableService_MutateRow_Handler,
 321                 },
 322                 {
 323                         MethodName: "MutateRows",
 324                         Handler:    _BigtableService_MutateRows_Handler,
 325                 },
 326                 {
 327                         MethodName: "CheckAndMutateRow",
 328                         Handler:    _BigtableService_CheckAndMutateRow_Handler,
 329                 },
 330                 {
 331                         MethodName: "ReadModifyWriteRow",
 332                         Handler:    _BigtableService_ReadModifyWriteRow_Handler,
 333                 },
 334         },
 335         Streams: []grpc.StreamDesc{
 336                 {
 337                         StreamName:    "ReadRows",
 338                         Handler:       _BigtableService_ReadRows_Handler,
 339                         ServerStreams: true,
 340                 },
 341                 {
 342                         StreamName:    "SampleRowKeys",
 343                         Handler:       _BigtableService_SampleRowKeys_Handler,
 344                         ServerStreams: true,
 345                 },
 346         },
 347         Metadata: "google/bigtable/v1/bigtable_service.proto",
 348 }
 349
 350 func init() { proto.RegisterFile("google/bigtable/v1/bigtable_service.proto", fileDescriptor1) }
 351
 352 var fileDescriptor1 = []byte{
 353         // 521 bytes of a gzipped FileDescriptorProto
 354         0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x94, 0xcd, 0x6e, 0xd4, 0x30,
 355         0x10, 0xc7, 0x65, 0x0e, 0xa8, 0x58, 0x42, 0x08, 0x4b, 0x14, 0x69, 0xe1, 0x14, 0xa0, 0xa2, 0x11,
 356         0x8d, 0xdb, 0x72, 0x0b, 0xe2, 0xd0, 0x45, 0x50, 0x21, 0x58, 0x51, 0xa5, 0xe2, 0x43, 0xe5, 0xb0,
 357         0x78, 0x93, 0x69, 0x08, 0x4d, 0xe2, 0x60, 0x7b, 0x37, 0x5a, 0xaa, 0x5e, 0x38, 0x71, 0xe7, 0x11,
 358         0x10, 0x17, 0x5e, 0x80, 0x23, 0xef, 0x00, 0x67, 0x6e, 0x3c, 0x08, 0xb2, 0x63, 0x2f, 0x2c, 0x0d,
 359         0xcb, 0x8a, 0xee, 0x29, 0x8e, 0xe6, 0x3f, 0x33, 0xbf, 0xff, 0xf8, 0x03, 0xaf, 0xa6, 0x9c, 0xa7,
 360         0x39, 0xd0, 0x41, 0x96, 0x2a, 0x36, 0xc8, 0x81, 0x8e, 0x36, 0x26, 0xeb, 0xbe, 0x04, 0x31, 0xca,
 361         0x62, 0x08, 0x2a, 0xc1, 0x15, 0x27, 0xa4, 0x91, 0x06, 0x2e, 0x1c, 0x8c, 0x36, 0x3a, 0x97, 0x6d,
 362         0x3a, 0xab, 0x32, 0xca, 0xca, 0x92, 0x2b, 0xa6, 0x32, 0x5e, 0xca, 0x26, 0xa3, 0xb3, 0x32, 0xab,
 363         0x78, 0xc2, 0x14, 0xb3, 0xba, 0xcd, 0x39, 0x20, 0xfa, 0x05, 0x48, 0xc9, 0x52, 0x70, 0xb5, 0x2f,
 364         0xd9, 0x1c, 0xf3, 0x37, 0x18, 0xee, 0x53, 0x28, 0x2a, 0x35, 0x6e, 0x82, 0x9b, 0xdf, 0x97, 0xf0,
 365         0xb9, 0xae, 0x2d, 0xb0, 0xdb, 0xe4, 0x93, 0x8f, 0x08, 0x2f, 0x45, 0xc0, 0x92, 0x88, 0xd7, 0x92,
 366         0x5c, 0x09, 0x8e, 0x9b, 0x09, 0x5c, 0x34, 0x82, 0xd7, 0x43, 0x90, 0xaa, 0x73, 0x75, 0xb6, 0x48,
 367         0x56, 0xbc, 0x94, 0xe0, 0x3d, 0x7c, 0xfb, 0xed, 0xc7, 0xfb, 0x53, 0xf7, 0xbc, 0x2d, 0x4d, 0x7d,
 368         0xd8, 0x30, 0x97, 0xac, 0x80, 0xdb, 0x95, 0xe0, 0xaf, 0x20, 0x56, 0x92, 0xfa, 0xf4, 0x0d, 0x2f,
 369         0x41, 0x7f, 0xe3, 0x7c, 0x28, 0x15, 0x08, 0xbd, 0x34, 0x42, 0x49, 0xfd, 0x23, 0x2a, 0x78, 0x2d,
 370         0x43, 0x01, 0x2c, 0x09, 0x91, 0xbf, 0x8e, 0xc8, 0x67, 0x84, 0xcf, 0xee, 0xb2, 0xa2, 0xca, 0x21,
 371         0xe2, 0xf5, 0x03, 0x18, 0x4b, 0x72, 0xbd, 0x8d, 0x63, 0x4a, 0xe2, 0x88, 0x57, 0xe7, 0x50, 0x5a,
 372         0xec, 0x47, 0x06, 0xfb, 0x3e, 0xd9, 0x3e, 0x11, 0xb6, 0x34, 0xb5, 0x75, 0xe1, 0x75, 0x44, 0x3e,
 373         0x20, 0x7c, 0xa6, 0x37, 0x54, 0x4c, 0xe9, 0x66, 0xa4, 0x75, 0x7a, 0x93, 0xb0, 0x23, 0x5e, 0x76,
 374         0x2a, 0xb7, 0x8f, 0xc1, 0x5d, 0xbd, 0x8f, 0xde, 0x33, 0x83, 0x17, 0x79, 0xbd, 0x93, 0xe0, 0xd1,
 375         0x43, 0xc1, 0xeb, 0xfe, 0x01, 0x8c, 0x8f, 0xc2, 0xc2, 0x34, 0x0e, 0x91, 0x4f, 0x3e, 0x21, 0x8c,
 376         0x27, 0x18, 0x92, 0x5c, 0x9b, 0x89, 0x39, 0x99, 0xec, 0xca, 0xbf, 0x64, 0x76, 0xac, 0x3d, 0xc3,
 377         0xbd, 0xed, 0x75, 0xff, 0x93, 0xdb, 0x82, 0xea, 0x9a, 0x1a, 0xf6, 0x2b, 0xc2, 0xe7, 0xef, 0xbc,
 378         0x84, 0xf8, 0x60, 0xab, 0x4c, 0x7e, 0x8d, 0xf6, 0x46, 0x1b, 0xcc, 0x31, 0x99, 0x43, 0x5f, 0x9b,
 379         0x53, 0x6d, 0x1d, 0xbc, 0x30, 0x0e, 0xf6, 0xbc, 0xc7, 0x0b, 0x9a, 0x7c, 0x3c, 0xd5, 0x49, 0x9b,
 380         0xfa, 0x82, 0x30, 0xd1, 0xd7, 0xa8, 0xc7, 0x93, 0x6c, 0x7f, 0xfc, 0x54, 0x64, 0x8d, 0xab, 0xb5,
 381         0xbf, 0x5d, 0xb7, 0x69, 0x9d, 0xb3, 0x75, 0xb1, 0x55, 0xce, 0x6b, 0x8f, 0x19, 0x03, 0xcf, 0xbd,
 382         0x27, 0x0b, 0x32, 0x20, 0xa6, 0x11, 0x42, 0xe4, 0x77, 0x2b, 0xbc, 0x1c, 0xf3, 0xa2, 0x05, 0xa0,
 383         0x7b, 0xe1, 0x8f, 0x67, 0x47, 0xee, 0xe8, 0x73, 0xbd, 0x83, 0xf6, 0x42, 0x2b, 0x4e, 0x79, 0xce,
 384         0xca, 0x34, 0xe0, 0x22, 0xa5, 0x29, 0x94, 0xe6, 0xd4, 0xd3, 0x26, 0xc4, 0xaa, 0x4c, 0xfe, 0xfe,
 385         0x04, 0xde, 0x72, 0xeb, 0x77, 0x08, 0x0d, 0x4e, 0x1b, 0xe5, 0xcd, 0x9f, 0x01, 0x00, 0x00, 0xff,
 386         0xff, 0x4c, 0x27, 0x6e, 0x9a, 0xb0, 0x05, 0x00, 0x00,
 387 }