@ -26,7 +26,6 @@ var _ = math.Inf
// proto package needs to be updated.
const _ = proto . GoGoProtoPackageIsVersion3 // please upgrade the proto package
// Define these here for compatibility but use tmlibs/kv.Pair.
type Pair struct {
Key [ ] byte ` protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty" `
Value [ ] byte ` protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty" `
@ -82,74 +81,16 @@ func (m *Pair) GetValue() []byte {
return nil
}
// Define these here for compatibility but use tmlibs/kv.KI64Pair.
type KI64Pair struct {
Key [ ] byte ` protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty" `
Value int64 ` protobuf:"varint,2,opt,name=value,proto3" json:"value,omitempty" `
XXX_NoUnkeyedLiteral struct { } ` json:"-" `
XXX_unrecognized [ ] byte ` json:"-" `
XXX_sizecache int32 ` json:"-" `
}
func ( m * KI64Pair ) Reset ( ) { * m = KI64Pair { } }
func ( m * KI64Pair ) String ( ) string { return proto . CompactTextString ( m ) }
func ( * KI64Pair ) ProtoMessage ( ) { }
func ( * KI64Pair ) Descriptor ( ) ( [ ] byte , [ ] int ) {
return fileDescriptor_31432671d164f444 , [ ] int { 1 }
}
func ( m * KI64Pair ) XXX_Unmarshal ( b [ ] byte ) error {
return m . Unmarshal ( b )
}
func ( m * KI64Pair ) XXX_Marshal ( b [ ] byte , deterministic bool ) ( [ ] byte , error ) {
if deterministic {
return xxx_messageInfo_KI64Pair . Marshal ( b , m , deterministic )
} else {
b = b [ : cap ( b ) ]
n , err := m . MarshalToSizedBuffer ( b )
if err != nil {
return nil , err
}
return b [ : n ] , nil
}
}
func ( m * KI64Pair ) XXX_Merge ( src proto . Message ) {
xxx_messageInfo_KI64Pair . Merge ( m , src )
}
func ( m * KI64Pair ) XXX_Size ( ) int {
return m . Size ( )
}
func ( m * KI64Pair ) XXX_DiscardUnknown ( ) {
xxx_messageInfo_KI64Pair . DiscardUnknown ( m )
}
var xxx_messageInfo_KI64Pair proto . InternalMessageInfo
func ( m * KI64Pair ) GetKey ( ) [ ] byte {
if m != nil {
return m . Key
}
return nil
}
func ( m * KI64Pair ) GetValue ( ) int64 {
if m != nil {
return m . Value
}
return 0
}
func init ( ) {
proto . RegisterType ( ( * Pair ) ( nil ) , "tendermint.libs.kv.Pair" )
golang_proto . RegisterType ( ( * Pair ) ( nil ) , "tendermint.libs.kv.Pair" )
proto . RegisterType ( ( * KI64Pair ) ( nil ) , "tendermint.libs.kv.KI64Pair" )
golang_proto . RegisterType ( ( * KI64Pair ) ( nil ) , "tendermint.libs.kv.KI64Pair" )
}
func init ( ) { proto . RegisterFile ( "libs/kv/types.proto" , fileDescriptor_31432671d164f444 ) }
func init ( ) { golang_proto . RegisterFile ( "libs/kv/types.proto" , fileDescriptor_31432671d164f444 ) }
var fileDescriptor_31432671d164f444 = [ ] byte {
// 196 bytes of a gzipped FileDescriptorProto
// 182 bytes of a gzipped FileDescriptorProto
0x1f , 0x8b , 0x08 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x02 , 0xff , 0xe2 , 0x12 , 0xce , 0xc9 , 0x4c , 0x2a ,
0xd6 , 0xcf , 0x2e , 0xd3 , 0x2f , 0xa9 , 0x2c , 0x48 , 0x2d , 0xd6 , 0x2b , 0x28 , 0xca , 0x2f , 0xc9 , 0x17 ,
0x12 , 0x2a , 0x49 , 0xcd , 0x4b , 0x49 , 0x2d , 0xca , 0xcd , 0xcc , 0x2b , 0xd1 , 0x03 , 0xc9 , 0xeb , 0x65 ,
@ -157,12 +98,11 @@ var fileDescriptor_31432671d164f444 = []byte{
0x95 , 0xe9 , 0xa7 , 0xe7 , 0xa7 , 0xe7 , 0x23 , 0x58 , 0x10 , 0xbd , 0x4a , 0x7a , 0x5c , 0x2c , 0x01 , 0x89 ,
0x99 , 0x45 , 0x42 , 0x02 , 0x5c , 0xcc , 0xd9 , 0xa9 , 0x95 , 0x12 , 0x8c , 0x0a , 0x8c , 0x1a , 0x3c , 0x41 ,
0x20 , 0xa6 , 0x90 , 0x08 , 0x17 , 0x6b , 0x59 , 0x62 , 0x4e , 0x69 , 0xaa , 0x04 , 0x13 , 0x58 , 0x0c , 0xc2 ,
0x51 , 0x32 , 0xe2 , 0xe2 , 0xf0 , 0xf6 , 0x34 , 0x33 , 0x21 , 0x46 , 0x0f , 0x33 , 0x54 , 0x8f , 0x93 , 0xdb ,
0x8f , 0x87 , 0x72 , 0x8c , 0x2b , 0x1e , 0xc9 , 0x31 , 0xee , 0x78 , 0x24 , 0xc7 , 0x78 , 0xe2 , 0x91 , 0x1c ,
0xe3 , 0x85 , 0x47 , 0x72 , 0x8c , 0x0f , 0x1e , 0xc9 , 0x31 , 0x1e , 0x78 , 0x2c , 0xc7 , 0x18 , 0xa5 , 0x91 ,
0x9e , 0x59 , 0x92 , 0x51 , 0x9a , 0xa4 , 0x97 , 0x9c , 0x9f , 0xab , 0x8f , 0xf0 , 0x08 , 0x32 , 0x13 , 0xea ,
0xe7 , 0x24 , 0x36 , 0xb0 , 0x93 , 0x8d , 0x01 , 0x01 , 0x00 , 0x00 , 0xff , 0xff , 0xc5 , 0x5f , 0x67 , 0xcb ,
0x05 , 0x01 , 0x00 , 0x00 ,
0x71 , 0x72 , 0xfb , 0xf1 , 0x50 , 0x8e , 0x71 , 0xc5 , 0x23 , 0x39 , 0xc6 , 0x1d , 0x8f , 0xe4 , 0x18 , 0x4f ,
0x3c , 0x92 , 0x63 , 0xbc , 0xf0 , 0x48 , 0x8e , 0xf1 , 0xc1 , 0x23 , 0x39 , 0xc6 , 0x03 , 0x8f , 0xe5 , 0x18 ,
0xa3 , 0x34 , 0xd2 , 0x33 , 0x4b , 0x32 , 0x4a , 0x93 , 0xf4 , 0x92 , 0xf3 , 0x73 , 0xf5 , 0x11 , 0x8e , 0x42 ,
0x66 , 0x42 , 0xdd , 0x9f , 0xc4 , 0x06 , 0xb6 , 0xde , 0x18 , 0x10 , 0x00 , 0x00 , 0xff , 0xff , 0x5d , 0x3a ,
0xdc , 0xba , 0xd1 , 0x00 , 0x00 , 0x00 ,
}
func ( this * Pair ) Equal ( that interface { } ) bool {
@ -195,36 +135,6 @@ func (this *Pair) Equal(that interface{}) bool {
}
return true
}
func ( this * KI64Pair ) Equal ( that interface { } ) bool {
if that == nil {
return this == nil
}
that1 , ok := that . ( * KI64Pair )
if ! ok {
that2 , ok := that . ( KI64Pair )
if ok {
that1 = & that2
} else {
return false
}
}
if that1 == nil {
return this == nil
} else if this == nil {
return false
}
if ! bytes . Equal ( this . Key , that1 . Key ) {
return false
}
if this . Value != that1 . Value {
return false
}
if ! bytes . Equal ( this . XXX_unrecognized , that1 . XXX_unrecognized ) {
return false
}
return true
}
func ( m * Pair ) Marshal ( ) ( dAtA [ ] byte , err error ) {
size := m . Size ( )
dAtA = make ( [ ] byte , size )
@ -266,45 +176,6 @@ func (m *Pair) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len ( dAtA ) - i , nil
}
func ( m * KI64Pair ) Marshal ( ) ( dAtA [ ] byte , err error ) {
size := m . Size ( )
dAtA = make ( [ ] byte , size )
n , err := m . MarshalToSizedBuffer ( dAtA [ : size ] )
if err != nil {
return nil , err
}
return dAtA [ : n ] , nil
}
func ( m * KI64Pair ) MarshalTo ( dAtA [ ] byte ) ( int , error ) {
size := m . Size ( )
return m . MarshalToSizedBuffer ( dAtA [ : size ] )
}
func ( m * KI64Pair ) MarshalToSizedBuffer ( dAtA [ ] byte ) ( int , error ) {
i := len ( dAtA )
_ = i
var l int
_ = l
if m . XXX_unrecognized != nil {
i -= len ( m . XXX_unrecognized )
copy ( dAtA [ i : ] , m . XXX_unrecognized )
}
if m . Value != 0 {
i = encodeVarintTypes ( dAtA , i , uint64 ( m . Value ) )
i --
dAtA [ i ] = 0x10
}
if len ( m . Key ) > 0 {
i -= len ( m . Key )
copy ( dAtA [ i : ] , m . Key )
i = encodeVarintTypes ( dAtA , i , uint64 ( len ( m . Key ) ) )
i --
dAtA [ i ] = 0xa
}
return len ( dAtA ) - i , nil
}
func encodeVarintTypes ( dAtA [ ] byte , offset int , v uint64 ) int {
offset -= sovTypes ( v )
base := offset
@ -334,23 +205,6 @@ func NewPopulatedPair(r randyTypes, easy bool) *Pair {
return this
}
func NewPopulatedKI64Pair ( r randyTypes , easy bool ) * KI64Pair {
this := & KI64Pair { }
v3 := r . Intn ( 100 )
this . Key = make ( [ ] byte , v3 )
for i := 0 ; i < v3 ; i ++ {
this . Key [ i ] = byte ( r . Intn ( 256 ) )
}
this . Value = int64 ( r . Int63 ( ) )
if r . Intn ( 2 ) == 0 {
this . Value *= - 1
}
if ! easy && r . Intn ( 10 ) != 0 {
this . XXX_unrecognized = randUnrecognizedTypes ( r , 3 )
}
return this
}
type randyTypes interface {
Float32 ( ) float32
Float64 ( ) float64
@ -370,9 +224,9 @@ func randUTF8RuneTypes(r randyTypes) rune {
return rune ( ru + 61 )
}
func randStringTypes ( r randyTypes ) string {
v4 := r . Intn ( 100 )
tmps := make ( [ ] rune , v4 )
for i := 0 ; i < v4 ; i ++ {
v3 := r . Intn ( 100 )
tmps := make ( [ ] rune , v3 )
for i := 0 ; i < v3 ; i ++ {
tmps [ i ] = randUTF8RuneTypes ( r )
}
return string ( tmps )
@ -394,11 +248,11 @@ func randFieldTypes(dAtA []byte, r randyTypes, fieldNumber int, wire int) []byte
switch wire {
case 0 :
dAtA = encodeVarintPopulateTypes ( dAtA , uint64 ( key ) )
v5 := r . Int63 ( )
v4 := r . Int63 ( )
if r . Intn ( 2 ) == 0 {
v5 *= - 1
v4 *= - 1
}
dAtA = encodeVarintPopulateTypes ( dAtA , uint64 ( v5 ) )
dAtA = encodeVarintPopulateTypes ( dAtA , uint64 ( v4 ) )
case 1 :
dAtA = encodeVarintPopulateTypes ( dAtA , uint64 ( key ) )
dAtA = append ( dAtA , byte ( r . Intn ( 256 ) ) , byte ( r . Intn ( 256 ) ) , byte ( r . Intn ( 256 ) ) , byte ( r . Intn ( 256 ) ) , byte ( r . Intn ( 256 ) ) , byte ( r . Intn ( 256 ) ) , byte ( r . Intn ( 256 ) ) , byte ( r . Intn ( 256 ) ) )
@ -443,25 +297,6 @@ func (m *Pair) Size() (n int) {
return n
}
func ( m * KI64Pair ) Size ( ) ( n int ) {
if m == nil {
return 0
}
var l int
_ = l
l = len ( m . Key )
if l > 0 {
n += 1 + l + sovTypes ( uint64 ( l ) )
}
if m . Value != 0 {
n += 1 + sovTypes ( uint64 ( m . Value ) )
}
if m . XXX_unrecognized != nil {
n += len ( m . XXX_unrecognized )
}
return n
}
func sovTypes ( x uint64 ) ( n int ) {
return ( math_bits . Len64 ( x | 1 ) + 6 ) / 7
}
@ -590,113 +425,6 @@ func (m *Pair) Unmarshal(dAtA []byte) error {
}
return nil
}
func ( m * KI64Pair ) Unmarshal ( dAtA [ ] byte ) error {
l := len ( dAtA )
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint ( 0 ) ; ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io . ErrUnexpectedEOF
}
b := dAtA [ iNdEx ]
iNdEx ++
wire |= uint64 ( b & 0x7F ) << shift
if b < 0x80 {
break
}
}
fieldNum := int32 ( wire >> 3 )
wireType := int ( wire & 0x7 )
if wireType == 4 {
return fmt . Errorf ( "proto: KI64Pair: wiretype end group for non-group" )
}
if fieldNum <= 0 {
return fmt . Errorf ( "proto: KI64Pair: illegal tag %d (wire type %d)" , fieldNum , wire )
}
switch fieldNum {
case 1 :
if wireType != 2 {
return fmt . Errorf ( "proto: wrong wireType = %d for field Key" , wireType )
}
var byteLen int
for shift := uint ( 0 ) ; ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io . ErrUnexpectedEOF
}
b := dAtA [ iNdEx ]
iNdEx ++
byteLen |= int ( b & 0x7F ) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
return ErrInvalidLengthTypes
}
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthTypes
}
if postIndex > l {
return io . ErrUnexpectedEOF
}
m . Key = append ( m . Key [ : 0 ] , dAtA [ iNdEx : postIndex ] ... )
if m . Key == nil {
m . Key = [ ] byte { }
}
iNdEx = postIndex
case 2 :
if wireType != 0 {
return fmt . Errorf ( "proto: wrong wireType = %d for field Value" , wireType )
}
m . Value = 0
for shift := uint ( 0 ) ; ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io . ErrUnexpectedEOF
}
b := dAtA [ iNdEx ]
iNdEx ++
m . Value |= int64 ( b & 0x7F ) << shift
if b < 0x80 {
break
}
}
default :
iNdEx = preIndex
skippy , err := skipTypes ( dAtA [ iNdEx : ] )
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthTypes
}
if ( iNdEx + skippy ) < 0 {
return ErrInvalidLengthTypes
}
if ( iNdEx + skippy ) > l {
return io . ErrUnexpectedEOF
}
m . XXX_unrecognized = append ( m . XXX_unrecognized , dAtA [ iNdEx : iNdEx + skippy ] ... )
iNdEx += skippy
}
}
if iNdEx > l {
return io . ErrUnexpectedEOF
}
return nil
}
func skipTypes ( dAtA [ ] byte ) ( n int , err error ) {
l := len ( dAtA )
iNdEx := 0
Callum Waters
5 years ago
GitHub