// Code generated by protoc-gen-go. DO NOT EDIT.
// source: file_read.proto

package rpc

import (
	context "context"
	fmt "fmt"
	math "math"

	proto "github.com/golang/protobuf/proto"
	wrappers "github.com/golang/protobuf/ptypes/wrappers"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package

// FileReadRequest represent the token delete request
type FileReadRequest struct {
	Token                string                `protobuf:"bytes,1,opt,name=token,proto3" json:"token,omitempty"`
	FileUid              string                `protobuf:"bytes,2,opt,name=file_uid,json=fileUid,proto3" json:"file_uid,omitempty"`
	Secret               *wrappers.StringValue `protobuf:"bytes,4,opt,name=secret,proto3" json:"secret,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

func (m *FileReadRequest) Reset()         { *m = FileReadRequest{} }
func (m *FileReadRequest) String() string { return proto.CompactTextString(m) }
func (*FileReadRequest) ProtoMessage()    {}
func (*FileReadRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_1151b28b7b17b6ad, []int{0}
}

func (m *FileReadRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_FileReadRequest.Unmarshal(m, b)
}
func (m *FileReadRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_FileReadRequest.Marshal(b, m, deterministic)
}
func (m *FileReadRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FileReadRequest.Merge(m, src)
}
func (m *FileReadRequest) XXX_Size() int {
	return xxx_messageInfo_FileReadRequest.Size(m)
}
func (m *FileReadRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_FileReadRequest.DiscardUnknown(m)
}

var xxx_messageInfo_FileReadRequest proto.InternalMessageInfo

func (m *FileReadRequest) GetToken() string {
	if m != nil {
		return m.Token
	}
	return ""
}

func (m *FileReadRequest) GetFileUid() string {
	if m != nil {
		return m.FileUid
	}
	return ""
}

func (m *FileReadRequest) GetSecret() *wrappers.StringValue {
	if m != nil {
		return m.Secret
	}
	return nil
}

// FileReadResponse represent the token delete response
type FileReadResponse struct {
	Content              []byte   `protobuf:"bytes,1,opt,name=content,proto3" json:"content,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *FileReadResponse) Reset()         { *m = FileReadResponse{} }
func (m *FileReadResponse) String() string { return proto.CompactTextString(m) }
func (*FileReadResponse) ProtoMessage()    {}
func (*FileReadResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_1151b28b7b17b6ad, []int{1}
}

func (m *FileReadResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_FileReadResponse.Unmarshal(m, b)
}
func (m *FileReadResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_FileReadResponse.Marshal(b, m, deterministic)
}
func (m *FileReadResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FileReadResponse.Merge(m, src)
}
func (m *FileReadResponse) XXX_Size() int {
	return xxx_messageInfo_FileReadResponse.Size(m)
}
func (m *FileReadResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_FileReadResponse.DiscardUnknown(m)
}

var xxx_messageInfo_FileReadResponse proto.InternalMessageInfo

func (m *FileReadResponse) GetContent() []byte {
	if m != nil {
		return m.Content
	}
	return nil
}

func init() {
	proto.RegisterType((*FileReadRequest)(nil), "bigfile.file_read.FileReadRequest")
	proto.RegisterType((*FileReadResponse)(nil), "bigfile.file_read.FileReadResponse")
}

func init() { proto.RegisterFile("file_read.proto", fileDescriptor_1151b28b7b17b6ad) }

var fileDescriptor_1151b28b7b17b6ad = []byte{
	// 301 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x90, 0xbf, 0x4e, 0xf3, 0x30,
	0x10, 0xc0, 0x3f, 0xf7, 0x83, 0xb6, 0x18, 0x50, 0x21, 0xea, 0x10, 0x2a, 0x54, 0xaa, 0xb0, 0x74,
	0x40, 0x2e, 0x2a, 0x3c, 0x41, 0x06, 0x16, 0x96, 0xc8, 0xfc, 0xa9, 0xc4, 0x82, 0x12, 0xe7, 0x1a,
	0x2c, 0x5c, 0xdb, 0xd8, 0x8e, 0x0a, 0xaf, 0xc3, 0xc8, 0x13, 0x32, 0xa2, 0x3a, 0x75, 0x91, 0x40,
	0x62, 0xb2, 0xef, 0xee, 0xe7, 0xfb, 0xdd, 0x19, 0xf7, 0xe6, 0x5c, 0xc0, 0xa3, 0x81, 0xbc, 0x24,
	0xda, 0x28, 0xa7, 0xa2, 0xc3, 0x82, 0x57, 0xab, 0x1c, 0xd9, 0x14, 0x06, 0xc3, 0x4a, 0xa9, 0x4a,
	0xc0, 0xc4, 0x03, 0x45, 0x3d, 0x9f, 0x2c, 0x4d, 0xae, 0x35, 0x18, 0xdb, 0x3c, 0x49, 0x5e, 0x71,
	0xef, 0x8a, 0x0b, 0xa0, 0x90, 0x97, 0x14, 0x5e, 0x6a, 0xb0, 0x2e, 0xea, 0xe3, 0x6d, 0xa7, 0x9e,
	0x41, 0xc6, 0x68, 0x84, 0xc6, 0x3b, 0xb4, 0x09, 0xa2, 0x23, 0xdc, 0xf5, 0x5d, 0x6b, 0x5e, 0xc6,
	0x2d, 0x5f, 0xe8, 0xac, 0xe2, 0x3b, 0x5e, 0x46, 0x97, 0xb8, 0x6d, 0x81, 0x19, 0x70, 0xf1, 0xd6,
	0x08, 0x8d, 0x77, 0xa7, 0xc7, 0xa4, 0x91, 0x92, 0x20, 0x25, 0x37, 0xce, 0x70, 0x59, 0xdd, 0xe7,
	0xa2, 0x06, 0xba, 0x66, 0x93, 0x33, 0x7c, 0xf0, 0x6d, 0xb6, 0x5a, 0x49, 0x0b, 0x51, 0x8c, 0x3b,
	0x4c, 0x49, 0x07, 0xd2, 0x79, 0xf9, 0x1e, 0x0d, 0xe1, 0x94, 0xe1, 0x6e, 0xa0, 0xa3, 0x59, 0x33,
	0x8a, 0xbf, 0x27, 0xe4, 0xd7, 0xce, 0xe4, 0xc7, 0x42, 0x83, 0xd3, 0x3f, 0x99, 0x46, 0x9d, 0xfc,
	0x3b, 0x47, 0xa9, 0xc1, 0x7d, 0xa6, 0x16, 0x1b, 0x3a, 0x8c, 0x9f, 0xee, 0x07, 0x3a, 0x5b, 0x65,
	0x32, 0xf4, 0x30, 0xac, 0xb8, 0x7b, 0xaa, 0x0b, 0xc2, 0xd4, 0x62, 0xb2, 0xa6, 0x37, 0xa7, 0xd1,
	0xec, 0x13, 0xa1, 0xf7, 0xd6, 0xff, 0x34, 0xa3, 0x1f, 0xad, 0x93, 0x74, 0xdd, 0x2c, 0x0b, 0x7f,
	0x31, 0x03, 0x21, 0xae, 0xa5, 0x5a, 0xca, 0xdb, 0x37, 0x0d, 0xb6, 0x68, 0x7b, 0xcb, 0xc5, 0x57,
	0x00, 0x00, 0x00, 0xff, 0xff, 0x0b, 0x43, 0x49, 0xbb, 0xcd, 0x01, 0x00, 0x00,
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// FileReadClient is the client API for FileRead service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type FileReadClient interface {
	FileRead(ctx context.Context, in *FileReadRequest, opts ...grpc.CallOption) (FileRead_FileReadClient, error)
}

type fileReadClient struct {
	cc *grpc.ClientConn
}

func NewFileReadClient(cc *grpc.ClientConn) FileReadClient {
	return &fileReadClient{cc}
}

func (c *fileReadClient) FileRead(ctx context.Context, in *FileReadRequest, opts ...grpc.CallOption) (FileRead_FileReadClient, error) {
	stream, err := c.cc.NewStream(ctx, &_FileRead_serviceDesc.Streams[0], "/bigfile.file_read.FileRead/fileRead", opts...)
	if err != nil {
		return nil, err
	}
	x := &fileReadFileReadClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type FileRead_FileReadClient interface {
	Recv() (*FileReadResponse, error)
	grpc.ClientStream
}

type fileReadFileReadClient struct {
	grpc.ClientStream
}

func (x *fileReadFileReadClient) Recv() (*FileReadResponse, error) {
	m := new(FileReadResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

// FileReadServer is the server API for FileRead service.
type FileReadServer interface {
	FileRead(*FileReadRequest, FileRead_FileReadServer) error
}

// UnimplementedFileReadServer can be embedded to have forward compatible implementations.
type UnimplementedFileReadServer struct {
}

func (*UnimplementedFileReadServer) FileRead(req *FileReadRequest, srv FileRead_FileReadServer) error {
	return status.Errorf(codes.Unimplemented, "method FileRead not implemented")
}

func RegisterFileReadServer(s *grpc.Server, srv FileReadServer) {
	s.RegisterService(&_FileRead_serviceDesc, srv)
}

func _FileRead_FileRead_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(FileReadRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(FileReadServer).FileRead(m, &fileReadFileReadServer{stream})
}

type FileRead_FileReadServer interface {
	Send(*FileReadResponse) error
	grpc.ServerStream
}

type fileReadFileReadServer struct {
	grpc.ServerStream
}

func (x *fileReadFileReadServer) Send(m *FileReadResponse) error {
	return x.ServerStream.SendMsg(m)
}

var _FileRead_serviceDesc = grpc.ServiceDesc{
	ServiceName: "bigfile.file_read.FileRead",
	HandlerType: (*FileReadServer)(nil),
	Methods:     []grpc.MethodDesc{},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "fileRead",
			Handler:       _FileRead_FileRead_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "file_read.proto",
}
