Themis.pb.go

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

/*
Package Themis is a generated protocol buffer package.

It is generated from these files:
	Themis.proto

It has these top-level messages:
	ThemisGetRequest
	ThemisBatchGetRequest
	ThemisBatchGetResponse
	ThemisPrewrite
	ThemisPrewriteRequest
	ThemisPrewriteResponse
	ThemisBatchPrewriteSecondaryRequest
	ThemisBatchPrewriteSecondaryResponse
	ThemisPrewriteResult
	ThemisCommitRequest
	ThemisCommitResponse
	ThemisBatchCommitSecondaryRequest
	ThemisBatchCommitSecondaryResponse
	ThemisBatchCommitSecondaryResult
	ThemisCommit
	EraseLockRequest
	EraseLockResponse
	LockExpiredRequest
	LockExpiredResponse
*/
package themis

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import Client "github.com/pingcap/go-hbase/proto"
import Cell "github.com/pingcap/go-hbase/proto"

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

type ThemisGetRequest struct {
	Get              *Client.Get `protobuf:"bytes,1,req,name=get" json:"get,omitempty"`
	StartTs          *uint64     `protobuf:"varint,2,req,name=startTs" json:"startTs,omitempty"`
	IgnoreLock       *bool       `protobuf:"varint,3,req,name=ignoreLock" json:"ignoreLock,omitempty"`
	XXX_unrecognized []byte      `json:"-"`
}

func (m *ThemisGetRequest) Reset()         { *m = ThemisGetRequest{} }
func (m *ThemisGetRequest) String() string { return proto.CompactTextString(m) }
func (*ThemisGetRequest) ProtoMessage()    {}

func (m *ThemisGetRequest) GetGet() *Client.Get {
	if m != nil {
		return m.Get
	}
	return nil
}

func (m *ThemisGetRequest) GetStartTs() uint64 {
	if m != nil && m.StartTs != nil {
		return *m.StartTs
	}
	return 0
}

func (m *ThemisGetRequest) GetIgnoreLock() bool {
	if m != nil && m.IgnoreLock != nil {
		return *m.IgnoreLock
	}
	return false
}

type ThemisBatchGetRequest struct {
	Gets             []*Client.Get `protobuf:"bytes,1,rep,name=gets" json:"gets,omitempty"`
	StartTs          *uint64       `protobuf:"varint,2,req,name=startTs" json:"startTs,omitempty"`
	IgnoreLock       *bool         `protobuf:"varint,3,req,name=ignoreLock" json:"ignoreLock,omitempty"`
	XXX_unrecognized []byte        `json:"-"`
}

func (m *ThemisBatchGetRequest) Reset()         { *m = ThemisBatchGetRequest{} }
func (m *ThemisBatchGetRequest) String() string { return proto.CompactTextString(m) }
func (*ThemisBatchGetRequest) ProtoMessage()    {}

func (m *ThemisBatchGetRequest) GetGets() []*Client.Get {
	if m != nil {
		return m.Gets
	}
	return nil
}

func (m *ThemisBatchGetRequest) GetStartTs() uint64 {
	if m != nil && m.StartTs != nil {
		return *m.StartTs
	}
	return 0
}

func (m *ThemisBatchGetRequest) GetIgnoreLock() bool {
	if m != nil && m.IgnoreLock != nil {
		return *m.IgnoreLock
	}
	return false
}

type ThemisBatchGetResponse struct {
	Rs               []*Client.Result `protobuf:"bytes,1,rep,name=rs" json:"rs,omitempty"`
	XXX_unrecognized []byte           `json:"-"`
}

func (m *ThemisBatchGetResponse) Reset()         { *m = ThemisBatchGetResponse{} }
func (m *ThemisBatchGetResponse) String() string { return proto.CompactTextString(m) }
func (*ThemisBatchGetResponse) ProtoMessage()    {}

func (m *ThemisBatchGetResponse) GetRs() []*Client.Result {
	if m != nil {
		return m.Rs
	}
	return nil
}

type ThemisPrewrite struct {
	Row              []byte       `protobuf:"bytes,1,req,name=row" json:"row,omitempty"`
	Mutations        []*Cell.Cell `protobuf:"bytes,2,rep,name=mutations" json:"mutations,omitempty"`
	XXX_unrecognized []byte       `json:"-"`
}

func (m *ThemisPrewrite) Reset()         { *m = ThemisPrewrite{} }
func (m *ThemisPrewrite) String() string { return proto.CompactTextString(m) }
func (*ThemisPrewrite) ProtoMessage()    {}

func (m *ThemisPrewrite) GetRow() []byte {
	if m != nil {
		return m.Row
	}
	return nil
}

func (m *ThemisPrewrite) GetMutations() []*Cell.Cell {
	if m != nil {
		return m.Mutations
	}
	return nil
}

type ThemisPrewriteRequest struct {
	ThemisPrewrite   *ThemisPrewrite `protobuf:"bytes,1,req,name=themisPrewrite" json:"themisPrewrite,omitempty"`
	PrewriteTs       *uint64         `protobuf:"varint,2,req,name=prewriteTs" json:"prewriteTs,omitempty"`
	SecondaryLock    []byte          `protobuf:"bytes,3,req,name=secondaryLock" json:"secondaryLock,omitempty"`
	PrimaryLock      []byte          `protobuf:"bytes,4,req,name=primaryLock" json:"primaryLock,omitempty"`
	PrimaryIndex     *int32          `protobuf:"varint,5,req,name=primaryIndex" json:"primaryIndex,omitempty"`
	XXX_unrecognized []byte          `json:"-"`
}

func (m *ThemisPrewriteRequest) Reset()         { *m = ThemisPrewriteRequest{} }
func (m *ThemisPrewriteRequest) String() string { return proto.CompactTextString(m) }
func (*ThemisPrewriteRequest) ProtoMessage()    {}

func (m *ThemisPrewriteRequest) GetThemisPrewrite() *ThemisPrewrite {
	if m != nil {
		return m.ThemisPrewrite
	}
	return nil
}

func (m *ThemisPrewriteRequest) GetPrewriteTs() uint64 {
	if m != nil && m.PrewriteTs != nil {
		return *m.PrewriteTs
	}
	return 0
}

func (m *ThemisPrewriteRequest) GetSecondaryLock() []byte {
	if m != nil {
		return m.SecondaryLock
	}
	return nil
}

func (m *ThemisPrewriteRequest) GetPrimaryLock() []byte {
	if m != nil {
		return m.PrimaryLock
	}
	return nil
}

func (m *ThemisPrewriteRequest) GetPrimaryIndex() int32 {
	if m != nil && m.PrimaryIndex != nil {
		return *m.PrimaryIndex
	}
	return 0
}

type ThemisPrewriteResponse struct {
	ThemisPrewriteResult *ThemisPrewriteResult `protobuf:"bytes,1,opt,name=themisPrewriteResult" json:"themisPrewriteResult,omitempty"`
	XXX_unrecognized     []byte                `json:"-"`
}

func (m *ThemisPrewriteResponse) Reset()         { *m = ThemisPrewriteResponse{} }
func (m *ThemisPrewriteResponse) String() string { return proto.CompactTextString(m) }
func (*ThemisPrewriteResponse) ProtoMessage()    {}

func (m *ThemisPrewriteResponse) GetThemisPrewriteResult() *ThemisPrewriteResult {
	if m != nil {
		return m.ThemisPrewriteResult
	}
	return nil
}

type ThemisBatchPrewriteSecondaryRequest struct {
	ThemisPrewrite   []*ThemisPrewrite `protobuf:"bytes,1,rep,name=themisPrewrite" json:"themisPrewrite,omitempty"`
	PrewriteTs       *uint64           `protobuf:"varint,2,req,name=prewriteTs" json:"prewriteTs,omitempty"`
	SecondaryLock    []byte            `protobuf:"bytes,3,req,name=secondaryLock" json:"secondaryLock,omitempty"`
	XXX_unrecognized []byte            `json:"-"`
}

func (m *ThemisBatchPrewriteSecondaryRequest) Reset()         { *m = ThemisBatchPrewriteSecondaryRequest{} }
func (m *ThemisBatchPrewriteSecondaryRequest) String() string { return proto.CompactTextString(m) }
func (*ThemisBatchPrewriteSecondaryRequest) ProtoMessage()    {}

func (m *ThemisBatchPrewriteSecondaryRequest) GetThemisPrewrite() []*ThemisPrewrite {
	if m != nil {
		return m.ThemisPrewrite
	}
	return nil
}

func (m *ThemisBatchPrewriteSecondaryRequest) GetPrewriteTs() uint64 {
	if m != nil && m.PrewriteTs != nil {
		return *m.PrewriteTs
	}
	return 0
}

func (m *ThemisBatchPrewriteSecondaryRequest) GetSecondaryLock() []byte {
	if m != nil {
		return m.SecondaryLock
	}
	return nil
}

type ThemisBatchPrewriteSecondaryResponse struct {
	ThemisPrewriteResult []*ThemisPrewriteResult `protobuf:"bytes,1,rep,name=themisPrewriteResult" json:"themisPrewriteResult,omitempty"`
	RowsNotInRegion      [][]byte                `protobuf:"bytes,2,rep,name=rowsNotInRegion" json:"rowsNotInRegion,omitempty"`
	XXX_unrecognized     []byte                  `json:"-"`
}

func (m *ThemisBatchPrewriteSecondaryResponse) Reset()         { *m = ThemisBatchPrewriteSecondaryResponse{} }
func (m *ThemisBatchPrewriteSecondaryResponse) String() string { return proto.CompactTextString(m) }
func (*ThemisBatchPrewriteSecondaryResponse) ProtoMessage()    {}

func (m *ThemisBatchPrewriteSecondaryResponse) GetThemisPrewriteResult() []*ThemisPrewriteResult {
	if m != nil {
		return m.ThemisPrewriteResult
	}
	return nil
}

func (m *ThemisBatchPrewriteSecondaryResponse) GetRowsNotInRegion() [][]byte {
	if m != nil {
		return m.RowsNotInRegion
	}
	return nil
}

type ThemisPrewriteResult struct {
	NewerWriteTs     *int64 `protobuf:"varint,1,req,name=newerWriteTs" json:"newerWriteTs,omitempty"`
	ExistLock        []byte `protobuf:"bytes,2,req,name=existLock" json:"existLock,omitempty"`
	Family           []byte `protobuf:"bytes,3,req,name=family" json:"family,omitempty"`
	Qualifier        []byte `protobuf:"bytes,4,req,name=qualifier" json:"qualifier,omitempty"`
	LockExpired      *bool  `protobuf:"varint,5,req,name=lockExpired" json:"lockExpired,omitempty"`
	Row              []byte `protobuf:"bytes,6,req,name=row" json:"row,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

func (m *ThemisPrewriteResult) Reset()         { *m = ThemisPrewriteResult{} }
func (m *ThemisPrewriteResult) String() string { return proto.CompactTextString(m) }
func (*ThemisPrewriteResult) ProtoMessage()    {}

func (m *ThemisPrewriteResult) GetNewerWriteTs() int64 {
	if m != nil && m.NewerWriteTs != nil {
		return *m.NewerWriteTs
	}
	return 0
}

func (m *ThemisPrewriteResult) GetExistLock() []byte {
	if m != nil {
		return m.ExistLock
	}
	return nil
}

func (m *ThemisPrewriteResult) GetFamily() []byte {
	if m != nil {
		return m.Family
	}
	return nil
}

func (m *ThemisPrewriteResult) GetQualifier() []byte {
	if m != nil {
		return m.Qualifier
	}
	return nil
}

func (m *ThemisPrewriteResult) GetLockExpired() bool {
	if m != nil && m.LockExpired != nil {
		return *m.LockExpired
	}
	return false
}

func (m *ThemisPrewriteResult) GetRow() []byte {
	if m != nil {
		return m.Row
	}
	return nil
}

type ThemisCommitRequest struct {
	ThemisCommit     *ThemisCommit `protobuf:"bytes,1,req,name=themisCommit" json:"themisCommit,omitempty"`
	XXX_unrecognized []byte        `json:"-"`
}

func (m *ThemisCommitRequest) Reset()         { *m = ThemisCommitRequest{} }
func (m *ThemisCommitRequest) String() string { return proto.CompactTextString(m) }
func (*ThemisCommitRequest) ProtoMessage()    {}

func (m *ThemisCommitRequest) GetThemisCommit() *ThemisCommit {
	if m != nil {
		return m.ThemisCommit
	}
	return nil
}

type ThemisCommitResponse struct {
	Result           *bool  `protobuf:"varint,1,req,name=result" json:"result,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

func (m *ThemisCommitResponse) Reset()         { *m = ThemisCommitResponse{} }
func (m *ThemisCommitResponse) String() string { return proto.CompactTextString(m) }
func (*ThemisCommitResponse) ProtoMessage()    {}

func (m *ThemisCommitResponse) GetResult() bool {
	if m != nil && m.Result != nil {
		return *m.Result
	}
	return false
}

type ThemisBatchCommitSecondaryRequest struct {
	ThemisCommit     []*ThemisCommit `protobuf:"bytes,1,rep,name=themisCommit" json:"themisCommit,omitempty"`
	XXX_unrecognized []byte          `json:"-"`
}

func (m *ThemisBatchCommitSecondaryRequest) Reset()         { *m = ThemisBatchCommitSecondaryRequest{} }
func (m *ThemisBatchCommitSecondaryRequest) String() string { return proto.CompactTextString(m) }
func (*ThemisBatchCommitSecondaryRequest) ProtoMessage()    {}

func (m *ThemisBatchCommitSecondaryRequest) GetThemisCommit() []*ThemisCommit {
	if m != nil {
		return m.ThemisCommit
	}
	return nil
}

type ThemisBatchCommitSecondaryResponse struct {
	BatchCommitSecondaryResult []*ThemisBatchCommitSecondaryResult `protobuf:"bytes,1,rep,name=batchCommitSecondaryResult" json:"batchCommitSecondaryResult,omitempty"`
	XXX_unrecognized           []byte                              `json:"-"`
}

func (m *ThemisBatchCommitSecondaryResponse) Reset()         { *m = ThemisBatchCommitSecondaryResponse{} }
func (m *ThemisBatchCommitSecondaryResponse) String() string { return proto.CompactTextString(m) }
func (*ThemisBatchCommitSecondaryResponse) ProtoMessage()    {}

func (m *ThemisBatchCommitSecondaryResponse) GetBatchCommitSecondaryResult() []*ThemisBatchCommitSecondaryResult {
	if m != nil {
		return m.BatchCommitSecondaryResult
	}
	return nil
}

type ThemisBatchCommitSecondaryResult struct {
	Row              []byte `protobuf:"bytes,1,req,name=row" json:"row,omitempty"`
	Success          *bool  `protobuf:"varint,2,req,name=success" json:"success,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

func (m *ThemisBatchCommitSecondaryResult) Reset()         { *m = ThemisBatchCommitSecondaryResult{} }
func (m *ThemisBatchCommitSecondaryResult) String() string { return proto.CompactTextString(m) }
func (*ThemisBatchCommitSecondaryResult) ProtoMessage()    {}

func (m *ThemisBatchCommitSecondaryResult) GetRow() []byte {
	if m != nil {
		return m.Row
	}
	return nil
}

func (m *ThemisBatchCommitSecondaryResult) GetSuccess() bool {
	if m != nil && m.Success != nil {
		return *m.Success
	}
	return false
}

type ThemisCommit struct {
	Row              []byte       `protobuf:"bytes,1,req,name=row" json:"row,omitempty"`
	Mutations        []*Cell.Cell `protobuf:"bytes,2,rep,name=mutations" json:"mutations,omitempty"`
	PrewriteTs       *uint64      `protobuf:"varint,3,req,name=prewriteTs" json:"prewriteTs,omitempty"`
	CommitTs         *uint64      `protobuf:"varint,4,req,name=commitTs" json:"commitTs,omitempty"`
	PrimaryIndex     *int32       `protobuf:"varint,5,req,name=primaryIndex" json:"primaryIndex,omitempty"`
	XXX_unrecognized []byte       `json:"-"`
}

func (m *ThemisCommit) Reset()         { *m = ThemisCommit{} }
func (m *ThemisCommit) String() string { return proto.CompactTextString(m) }
func (*ThemisCommit) ProtoMessage()    {}

func (m *ThemisCommit) GetRow() []byte {
	if m != nil {
		return m.Row
	}
	return nil
}

func (m *ThemisCommit) GetMutations() []*Cell.Cell {
	if m != nil {
		return m.Mutations
	}
	return nil
}

func (m *ThemisCommit) GetPrewriteTs() uint64 {
	if m != nil && m.PrewriteTs != nil {
		return *m.PrewriteTs
	}
	return 0
}

func (m *ThemisCommit) GetCommitTs() uint64 {
	if m != nil && m.CommitTs != nil {
		return *m.CommitTs
	}
	return 0
}

func (m *ThemisCommit) GetPrimaryIndex() int32 {
	if m != nil && m.PrimaryIndex != nil {
		return *m.PrimaryIndex
	}
	return 0
}

type EraseLockRequest struct {
	Row              []byte  `protobuf:"bytes,1,req,name=row" json:"row,omitempty"`
	Family           []byte  `protobuf:"bytes,2,req,name=family" json:"family,omitempty"`
	Qualifier        []byte  `protobuf:"bytes,3,req,name=qualifier" json:"qualifier,omitempty"`
	PrewriteTs       *uint64 `protobuf:"varint,4,req,name=prewriteTs" json:"prewriteTs,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *EraseLockRequest) Reset()         { *m = EraseLockRequest{} }
func (m *EraseLockRequest) String() string { return proto.CompactTextString(m) }
func (*EraseLockRequest) ProtoMessage()    {}

func (m *EraseLockRequest) GetRow() []byte {
	if m != nil {
		return m.Row
	}
	return nil
}

func (m *EraseLockRequest) GetFamily() []byte {
	if m != nil {
		return m.Family
	}
	return nil
}

func (m *EraseLockRequest) GetQualifier() []byte {
	if m != nil {
		return m.Qualifier
	}
	return nil
}

func (m *EraseLockRequest) GetPrewriteTs() uint64 {
	if m != nil && m.PrewriteTs != nil {
		return *m.PrewriteTs
	}
	return 0
}

type EraseLockResponse struct {
	Lock             []byte `protobuf:"bytes,1,opt,name=lock" json:"lock,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

func (m *EraseLockResponse) Reset()         { *m = EraseLockResponse{} }
func (m *EraseLockResponse) String() string { return proto.CompactTextString(m) }
func (*EraseLockResponse) ProtoMessage()    {}

func (m *EraseLockResponse) GetLock() []byte {
	if m != nil {
		return m.Lock
	}
	return nil
}

type LockExpiredRequest struct {
	Timestamp        *uint64 `protobuf:"varint,1,req,name=timestamp" json:"timestamp,omitempty"`
	XXX_unrecognized []byte  `json:"-"`
}

func (m *LockExpiredRequest) Reset()         { *m = LockExpiredRequest{} }
func (m *LockExpiredRequest) String() string { return proto.CompactTextString(m) }
func (*LockExpiredRequest) ProtoMessage()    {}

func (m *LockExpiredRequest) GetTimestamp() uint64 {
	if m != nil && m.Timestamp != nil {
		return *m.Timestamp
	}
	return 0
}

type LockExpiredResponse struct {
	Expired          *bool  `protobuf:"varint,1,req,name=expired" json:"expired,omitempty"`
	XXX_unrecognized []byte `json:"-"`
}

func (m *LockExpiredResponse) Reset()         { *m = LockExpiredResponse{} }
func (m *LockExpiredResponse) String() string { return proto.CompactTextString(m) }
func (*LockExpiredResponse) ProtoMessage()    {}

func (m *LockExpiredResponse) GetExpired() bool {
	if m != nil && m.Expired != nil {
		return *m.Expired
	}
	return false
}