vendor/google.golang.org/genproto/googleapis/bigtable/v2/data.pb.go

   1 // Code generated by protoc-gen-go. DO NOT EDIT.
   2 // source: google/bigtable/v2/data.proto
   3
   4 package bigtable
   5
   6 import proto "github.com/golang/protobuf/proto"
   7 import fmt "fmt"
   8 import math "math"
   9
  10 // Reference imports to suppress errors if they are not otherwise used.
  11 var _ = proto.Marshal
  12 var _ = fmt.Errorf
  13 var _ = math.Inf
  14
  15 // Specifies the complete (requested) contents of a single row of a table.
  16 // Rows which exceed 256MiB in size cannot be read in full.
  17 type Row struct {
  18         // The unique key which identifies this row within its table. This is the same
  19         // key that's used to identify the row in, for example, a MutateRowRequest.
  20         // May contain any non-empty byte string up to 4KiB in length.
  21         Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
  22         // May be empty, but only if the entire row is empty.
  23         // The mutual ordering of column families is not specified.
  24         Families []*Family `protobuf:"bytes,2,rep,name=families" json:"families,omitempty"`
  25 }
  26
  27 func (m *Row) Reset()                    { *m = Row{} }
  28 func (m *Row) String() string            { return proto.CompactTextString(m) }
  29 func (*Row) ProtoMessage()               {}
  30 func (*Row) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{0} }
  31
  32 func (m *Row) GetKey() []byte {
  33         if m != nil {
  34                 return m.Key
  35         }
  36         return nil
  37 }
  38
  39 func (m *Row) GetFamilies() []*Family {
  40         if m != nil {
  41                 return m.Families
  42         }
  43         return nil
  44 }
  45
  46 // Specifies (some of) the contents of a single row/column family intersection
  47 // of a table.
  48 type Family struct {
  49         // The unique key which identifies this family within its row. This is the
  50         // same key that's used to identify the family in, for example, a RowFilter
  51         // which sets its "family_name_regex_filter" field.
  52         // Must match `[-_.a-zA-Z0-9]+`, except that AggregatingRowProcessors may
  53         // produce cells in a sentinel family with an empty name.
  54         // Must be no greater than 64 characters in length.
  55         Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
  56         // Must not be empty. Sorted in order of increasing "qualifier".
  57         Columns []*Column `protobuf:"bytes,2,rep,name=columns" json:"columns,omitempty"`
  58 }
  59
  60 func (m *Family) Reset()                    { *m = Family{} }
  61 func (m *Family) String() string            { return proto.CompactTextString(m) }
  62 func (*Family) ProtoMessage()               {}
  63 func (*Family) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{1} }
  64
  65 func (m *Family) GetName() string {
  66         if m != nil {
  67                 return m.Name
  68         }
  69         return ""
  70 }
  71
  72 func (m *Family) GetColumns() []*Column {
  73         if m != nil {
  74                 return m.Columns
  75         }
  76         return nil
  77 }
  78
  79 // Specifies (some of) the contents of a single row/column intersection of a
  80 // table.
  81 type Column struct {
  82         // The unique key which identifies this column within its family. This is the
  83         // same key that's used to identify the column in, for example, a RowFilter
  84         // which sets its `column_qualifier_regex_filter` field.
  85         // May contain any byte string, including the empty string, up to 16kiB in
  86         // length.
  87         Qualifier []byte `protobuf:"bytes,1,opt,name=qualifier,proto3" json:"qualifier,omitempty"`
  88         // Must not be empty. Sorted in order of decreasing "timestamp_micros".
  89         Cells []*Cell `protobuf:"bytes,2,rep,name=cells" json:"cells,omitempty"`
  90 }
  91
  92 func (m *Column) Reset()                    { *m = Column{} }
  93 func (m *Column) String() string            { return proto.CompactTextString(m) }
  94 func (*Column) ProtoMessage()               {}
  95 func (*Column) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{2} }
  96
  97 func (m *Column) GetQualifier() []byte {
  98         if m != nil {
  99                 return m.Qualifier
 100         }
 101         return nil
 102 }
 103
 104 func (m *Column) GetCells() []*Cell {
 105         if m != nil {
 106                 return m.Cells
 107         }
 108         return nil
 109 }
 110
 111 // Specifies (some of) the contents of a single row/column/timestamp of a table.
 112 type Cell struct {
 113         // The cell's stored timestamp, which also uniquely identifies it within
 114         // its column.
 115         // Values are always expressed in microseconds, but individual tables may set
 116         // a coarser granularity to further restrict the allowed values. For
 117         // example, a table which specifies millisecond granularity will only allow
 118         // values of `timestamp_micros` which are multiples of 1000.
 119         TimestampMicros int64 `protobuf:"varint,1,opt,name=timestamp_micros,json=timestampMicros" json:"timestamp_micros,omitempty"`
 120         // The value stored in the cell.
 121         // May contain any byte string, including the empty string, up to 100MiB in
 122         // length.
 123         Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
 124         // Labels applied to the cell by a [RowFilter][google.bigtable.v2.RowFilter].
 125         Labels []string `protobuf:"bytes,3,rep,name=labels" json:"labels,omitempty"`
 126 }
 127
 128 func (m *Cell) Reset()                    { *m = Cell{} }
 129 func (m *Cell) String() string            { return proto.CompactTextString(m) }
 130 func (*Cell) ProtoMessage()               {}
 131 func (*Cell) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{3} }
 132
 133 func (m *Cell) GetTimestampMicros() int64 {
 134         if m != nil {
 135                 return m.TimestampMicros
 136         }
 137         return 0
 138 }
 139
 140 func (m *Cell) GetValue() []byte {
 141         if m != nil {
 142                 return m.Value
 143         }
 144         return nil
 145 }
 146
 147 func (m *Cell) GetLabels() []string {
 148         if m != nil {
 149                 return m.Labels
 150         }
 151         return nil
 152 }
 153
 154 // Specifies a contiguous range of rows.
 155 type RowRange struct {
 156         // The row key at which to start the range.
 157         // If neither field is set, interpreted as the empty string, inclusive.
 158         //
 159         // Types that are valid to be assigned to StartKey:
 160         //      *RowRange_StartKeyClosed
 161         //      *RowRange_StartKeyOpen
 162         StartKey isRowRange_StartKey `protobuf_oneof:"start_key"`
 163         // The row key at which to end the range.
 164         // If neither field is set, interpreted as the infinite row key, exclusive.
 165         //
 166         // Types that are valid to be assigned to EndKey:
 167         //      *RowRange_EndKeyOpen
 168         //      *RowRange_EndKeyClosed
 169         EndKey isRowRange_EndKey `protobuf_oneof:"end_key"`
 170 }
 171
 172 func (m *RowRange) Reset()                    { *m = RowRange{} }
 173 func (m *RowRange) String() string            { return proto.CompactTextString(m) }
 174 func (*RowRange) ProtoMessage()               {}
 175 func (*RowRange) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{4} }
 176
 177 type isRowRange_StartKey interface {
 178         isRowRange_StartKey()
 179 }
 180 type isRowRange_EndKey interface {
 181         isRowRange_EndKey()
 182 }
 183
 184 type RowRange_StartKeyClosed struct {
 185         StartKeyClosed []byte `protobuf:"bytes,1,opt,name=start_key_closed,json=startKeyClosed,proto3,oneof"`
 186 }
 187 type RowRange_StartKeyOpen struct {
 188         StartKeyOpen []byte `protobuf:"bytes,2,opt,name=start_key_open,json=startKeyOpen,proto3,oneof"`
 189 }
 190 type RowRange_EndKeyOpen struct {
 191         EndKeyOpen []byte `protobuf:"bytes,3,opt,name=end_key_open,json=endKeyOpen,proto3,oneof"`
 192 }
 193 type RowRange_EndKeyClosed struct {
 194         EndKeyClosed []byte `protobuf:"bytes,4,opt,name=end_key_closed,json=endKeyClosed,proto3,oneof"`
 195 }
 196
 197 func (*RowRange_StartKeyClosed) isRowRange_StartKey() {}
 198 func (*RowRange_StartKeyOpen) isRowRange_StartKey()   {}
 199 func (*RowRange_EndKeyOpen) isRowRange_EndKey()       {}
 200 func (*RowRange_EndKeyClosed) isRowRange_EndKey()     {}
 201
 202 func (m *RowRange) GetStartKey() isRowRange_StartKey {
 203         if m != nil {
 204                 return m.StartKey
 205         }
 206         return nil
 207 }
 208 func (m *RowRange) GetEndKey() isRowRange_EndKey {
 209         if m != nil {
 210                 return m.EndKey
 211         }
 212         return nil
 213 }
 214
 215 func (m *RowRange) GetStartKeyClosed() []byte {
 216         if x, ok := m.GetStartKey().(*RowRange_StartKeyClosed); ok {
 217                 return x.StartKeyClosed
 218         }
 219         return nil
 220 }
 221
 222 func (m *RowRange) GetStartKeyOpen() []byte {
 223         if x, ok := m.GetStartKey().(*RowRange_StartKeyOpen); ok {
 224                 return x.StartKeyOpen
 225         }
 226         return nil
 227 }
 228
 229 func (m *RowRange) GetEndKeyOpen() []byte {
 230         if x, ok := m.GetEndKey().(*RowRange_EndKeyOpen); ok {
 231                 return x.EndKeyOpen
 232         }
 233         return nil
 234 }
 235
 236 func (m *RowRange) GetEndKeyClosed() []byte {
 237         if x, ok := m.GetEndKey().(*RowRange_EndKeyClosed); ok {
 238                 return x.EndKeyClosed
 239         }
 240         return nil
 241 }
 242
 243 // XXX_OneofFuncs is for the internal use of the proto package.
 244 func (*RowRange) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
 245         return _RowRange_OneofMarshaler, _RowRange_OneofUnmarshaler, _RowRange_OneofSizer, []interface{}{
 246                 (*RowRange_StartKeyClosed)(nil),
 247                 (*RowRange_StartKeyOpen)(nil),
 248                 (*RowRange_EndKeyOpen)(nil),
 249                 (*RowRange_EndKeyClosed)(nil),
 250         }
 251 }
 252
 253 func _RowRange_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
 254         m := msg.(*RowRange)
 255         // start_key
 256         switch x := m.StartKey.(type) {
 257         case *RowRange_StartKeyClosed:
 258                 b.EncodeVarint(1<<3 | proto.WireBytes)
 259                 b.EncodeRawBytes(x.StartKeyClosed)
 260         case *RowRange_StartKeyOpen:
 261                 b.EncodeVarint(2<<3 | proto.WireBytes)
 262                 b.EncodeRawBytes(x.StartKeyOpen)
 263         case nil:
 264         default:
 265                 return fmt.Errorf("RowRange.StartKey has unexpected type %T", x)
 266         }
 267         // end_key
 268         switch x := m.EndKey.(type) {
 269         case *RowRange_EndKeyOpen:
 270                 b.EncodeVarint(3<<3 | proto.WireBytes)
 271                 b.EncodeRawBytes(x.EndKeyOpen)
 272         case *RowRange_EndKeyClosed:
 273                 b.EncodeVarint(4<<3 | proto.WireBytes)
 274                 b.EncodeRawBytes(x.EndKeyClosed)
 275         case nil:
 276         default:
 277                 return fmt.Errorf("RowRange.EndKey has unexpected type %T", x)
 278         }
 279         return nil
 280 }
 281
 282 func _RowRange_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
 283         m := msg.(*RowRange)
 284         switch tag {
 285         case 1: // start_key.start_key_closed
 286                 if wire != proto.WireBytes {
 287                         return true, proto.ErrInternalBadWireType
 288                 }
 289                 x, err := b.DecodeRawBytes(true)
 290                 m.StartKey = &RowRange_StartKeyClosed{x}
 291                 return true, err
 292         case 2: // start_key.start_key_open
 293                 if wire != proto.WireBytes {
 294                         return true, proto.ErrInternalBadWireType
 295                 }
 296                 x, err := b.DecodeRawBytes(true)
 297                 m.StartKey = &RowRange_StartKeyOpen{x}
 298                 return true, err
 299         case 3: // end_key.end_key_open
 300                 if wire != proto.WireBytes {
 301                         return true, proto.ErrInternalBadWireType
 302                 }
 303                 x, err := b.DecodeRawBytes(true)
 304                 m.EndKey = &RowRange_EndKeyOpen{x}
 305                 return true, err
 306         case 4: // end_key.end_key_closed
 307                 if wire != proto.WireBytes {
 308                         return true, proto.ErrInternalBadWireType
 309                 }
 310                 x, err := b.DecodeRawBytes(true)
 311                 m.EndKey = &RowRange_EndKeyClosed{x}
 312                 return true, err
 313         default:
 314                 return false, nil
 315         }
 316 }
 317
 318 func _RowRange_OneofSizer(msg proto.Message) (n int) {
 319         m := msg.(*RowRange)
 320         // start_key
 321         switch x := m.StartKey.(type) {
 322         case *RowRange_StartKeyClosed:
 323                 n += proto.SizeVarint(1<<3 | proto.WireBytes)
 324                 n += proto.SizeVarint(uint64(len(x.StartKeyClosed)))
 325                 n += len(x.StartKeyClosed)
 326         case *RowRange_StartKeyOpen:
 327                 n += proto.SizeVarint(2<<3 | proto.WireBytes)
 328                 n += proto.SizeVarint(uint64(len(x.StartKeyOpen)))
 329                 n += len(x.StartKeyOpen)
 330         case nil:
 331         default:
 332                 panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
 333         }
 334         // end_key
 335         switch x := m.EndKey.(type) {
 336         case *RowRange_EndKeyOpen:
 337                 n += proto.SizeVarint(3<<3 | proto.WireBytes)
 338                 n += proto.SizeVarint(uint64(len(x.EndKeyOpen)))
 339                 n += len(x.EndKeyOpen)
 340         case *RowRange_EndKeyClosed:
 341                 n += proto.SizeVarint(4<<3 | proto.WireBytes)
 342                 n += proto.SizeVarint(uint64(len(x.EndKeyClosed)))
 343                 n += len(x.EndKeyClosed)
 344         case nil:
 345         default:
 346                 panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
 347         }
 348         return n
 349 }
 350
 351 // Specifies a non-contiguous set of rows.
 352 type RowSet struct {
 353         // Single rows included in the set.
 354         RowKeys [][]byte `protobuf:"bytes,1,rep,name=row_keys,json=rowKeys,proto3" json:"row_keys,omitempty"`
 355         // Contiguous row ranges included in the set.
 356         RowRanges []*RowRange `protobuf:"bytes,2,rep,name=row_ranges,json=rowRanges" json:"row_ranges,omitempty"`
 357 }
 358
 359 func (m *RowSet) Reset()                    { *m = RowSet{} }
 360 func (m *RowSet) String() string            { return proto.CompactTextString(m) }
 361 func (*RowSet) ProtoMessage()               {}
 362 func (*RowSet) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{5} }
 363
 364 func (m *RowSet) GetRowKeys() [][]byte {
 365         if m != nil {
 366                 return m.RowKeys
 367         }
 368         return nil
 369 }
 370
 371 func (m *RowSet) GetRowRanges() []*RowRange {
 372         if m != nil {
 373                 return m.RowRanges
 374         }
 375         return nil
 376 }
 377
 378 // Specifies a contiguous range of columns within a single column family.
 379 // The range spans from &lt;column_family&gt;:&lt;start_qualifier&gt; to
 380 // &lt;column_family&gt;:&lt;end_qualifier&gt;, where both bounds can be either
 381 // inclusive or exclusive.
 382 type ColumnRange struct {
 383         // The name of the column family within which this range falls.
 384         FamilyName string `protobuf:"bytes,1,opt,name=family_name,json=familyName" json:"family_name,omitempty"`
 385         // The column qualifier at which to start the range (within `column_family`).
 386         // If neither field is set, interpreted as the empty string, inclusive.
 387         //
 388         // Types that are valid to be assigned to StartQualifier:
 389         //      *ColumnRange_StartQualifierClosed
 390         //      *ColumnRange_StartQualifierOpen
 391         StartQualifier isColumnRange_StartQualifier `protobuf_oneof:"start_qualifier"`
 392         // The column qualifier at which to end the range (within `column_family`).
 393         // If neither field is set, interpreted as the infinite string, exclusive.
 394         //
 395         // Types that are valid to be assigned to EndQualifier:
 396         //      *ColumnRange_EndQualifierClosed
 397         //      *ColumnRange_EndQualifierOpen
 398         EndQualifier isColumnRange_EndQualifier `protobuf_oneof:"end_qualifier"`
 399 }
 400
 401 func (m *ColumnRange) Reset()                    { *m = ColumnRange{} }
 402 func (m *ColumnRange) String() string            { return proto.CompactTextString(m) }
 403 func (*ColumnRange) ProtoMessage()               {}
 404 func (*ColumnRange) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{6} }
 405
 406 type isColumnRange_StartQualifier interface {
 407         isColumnRange_StartQualifier()
 408 }
 409 type isColumnRange_EndQualifier interface {
 410         isColumnRange_EndQualifier()
 411 }
 412
 413 type ColumnRange_StartQualifierClosed struct {
 414         StartQualifierClosed []byte `protobuf:"bytes,2,opt,name=start_qualifier_closed,json=startQualifierClosed,proto3,oneof"`
 415 }
 416 type ColumnRange_StartQualifierOpen struct {
 417         StartQualifierOpen []byte `protobuf:"bytes,3,opt,name=start_qualifier_open,json=startQualifierOpen,proto3,oneof"`
 418 }
 419 type ColumnRange_EndQualifierClosed struct {
 420         EndQualifierClosed []byte `protobuf:"bytes,4,opt,name=end_qualifier_closed,json=endQualifierClosed,proto3,oneof"`
 421 }
 422 type ColumnRange_EndQualifierOpen struct {
 423         EndQualifierOpen []byte `protobuf:"bytes,5,opt,name=end_qualifier_open,json=endQualifierOpen,proto3,oneof"`
 424 }
 425
 426 func (*ColumnRange_StartQualifierClosed) isColumnRange_StartQualifier() {}
 427 func (*ColumnRange_StartQualifierOpen) isColumnRange_StartQualifier()   {}
 428 func (*ColumnRange_EndQualifierClosed) isColumnRange_EndQualifier()     {}
 429 func (*ColumnRange_EndQualifierOpen) isColumnRange_EndQualifier()       {}
 430
 431 func (m *ColumnRange) GetStartQualifier() isColumnRange_StartQualifier {
 432         if m != nil {
 433                 return m.StartQualifier
 434         }
 435         return nil
 436 }
 437 func (m *ColumnRange) GetEndQualifier() isColumnRange_EndQualifier {
 438         if m != nil {
 439                 return m.EndQualifier
 440         }
 441         return nil
 442 }
 443
 444 func (m *ColumnRange) GetFamilyName() string {
 445         if m != nil {
 446                 return m.FamilyName
 447         }
 448         return ""
 449 }
 450
 451 func (m *ColumnRange) GetStartQualifierClosed() []byte {
 452         if x, ok := m.GetStartQualifier().(*ColumnRange_StartQualifierClosed); ok {
 453                 return x.StartQualifierClosed
 454         }
 455         return nil
 456 }
 457
 458 func (m *ColumnRange) GetStartQualifierOpen() []byte {
 459         if x, ok := m.GetStartQualifier().(*ColumnRange_StartQualifierOpen); ok {
 460                 return x.StartQualifierOpen
 461         }
 462         return nil
 463 }
 464
 465 func (m *ColumnRange) GetEndQualifierClosed() []byte {
 466         if x, ok := m.GetEndQualifier().(*ColumnRange_EndQualifierClosed); ok {
 467                 return x.EndQualifierClosed
 468         }
 469         return nil
 470 }
 471
 472 func (m *ColumnRange) GetEndQualifierOpen() []byte {
 473         if x, ok := m.GetEndQualifier().(*ColumnRange_EndQualifierOpen); ok {
 474                 return x.EndQualifierOpen
 475         }
 476         return nil
 477 }
 478
 479 // XXX_OneofFuncs is for the internal use of the proto package.
 480 func (*ColumnRange) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
 481         return _ColumnRange_OneofMarshaler, _ColumnRange_OneofUnmarshaler, _ColumnRange_OneofSizer, []interface{}{
 482                 (*ColumnRange_StartQualifierClosed)(nil),
 483                 (*ColumnRange_StartQualifierOpen)(nil),
 484                 (*ColumnRange_EndQualifierClosed)(nil),
 485                 (*ColumnRange_EndQualifierOpen)(nil),
 486         }
 487 }
 488
 489 func _ColumnRange_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
 490         m := msg.(*ColumnRange)
 491         // start_qualifier
 492         switch x := m.StartQualifier.(type) {
 493         case *ColumnRange_StartQualifierClosed:
 494                 b.EncodeVarint(2<<3 | proto.WireBytes)
 495                 b.EncodeRawBytes(x.StartQualifierClosed)
 496         case *ColumnRange_StartQualifierOpen:
 497                 b.EncodeVarint(3<<3 | proto.WireBytes)
 498                 b.EncodeRawBytes(x.StartQualifierOpen)
 499         case nil:
 500         default:
 501                 return fmt.Errorf("ColumnRange.StartQualifier has unexpected type %T", x)
 502         }
 503         // end_qualifier
 504         switch x := m.EndQualifier.(type) {
 505         case *ColumnRange_EndQualifierClosed:
 506                 b.EncodeVarint(4<<3 | proto.WireBytes)
 507                 b.EncodeRawBytes(x.EndQualifierClosed)
 508         case *ColumnRange_EndQualifierOpen:
 509                 b.EncodeVarint(5<<3 | proto.WireBytes)
 510                 b.EncodeRawBytes(x.EndQualifierOpen)
 511         case nil:
 512         default:
 513                 return fmt.Errorf("ColumnRange.EndQualifier has unexpected type %T", x)
 514         }
 515         return nil
 516 }
 517
 518 func _ColumnRange_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
 519         m := msg.(*ColumnRange)
 520         switch tag {
 521         case 2: // start_qualifier.start_qualifier_closed
 522                 if wire != proto.WireBytes {
 523                         return true, proto.ErrInternalBadWireType
 524                 }
 525                 x, err := b.DecodeRawBytes(true)
 526                 m.StartQualifier = &ColumnRange_StartQualifierClosed{x}
 527                 return true, err
 528         case 3: // start_qualifier.start_qualifier_open
 529                 if wire != proto.WireBytes {
 530                         return true, proto.ErrInternalBadWireType
 531                 }
 532                 x, err := b.DecodeRawBytes(true)
 533                 m.StartQualifier = &ColumnRange_StartQualifierOpen{x}
 534                 return true, err
 535         case 4: // end_qualifier.end_qualifier_closed
 536                 if wire != proto.WireBytes {
 537                         return true, proto.ErrInternalBadWireType
 538                 }
 539                 x, err := b.DecodeRawBytes(true)
 540                 m.EndQualifier = &ColumnRange_EndQualifierClosed{x}
 541                 return true, err
 542         case 5: // end_qualifier.end_qualifier_open
 543                 if wire != proto.WireBytes {
 544                         return true, proto.ErrInternalBadWireType
 545                 }
 546                 x, err := b.DecodeRawBytes(true)
 547                 m.EndQualifier = &ColumnRange_EndQualifierOpen{x}
 548                 return true, err
 549         default:
 550                 return false, nil
 551         }
 552 }
 553
 554 func _ColumnRange_OneofSizer(msg proto.Message) (n int) {
 555         m := msg.(*ColumnRange)
 556         // start_qualifier
 557         switch x := m.StartQualifier.(type) {
 558         case *ColumnRange_StartQualifierClosed:
 559                 n += proto.SizeVarint(2<<3 | proto.WireBytes)
 560                 n += proto.SizeVarint(uint64(len(x.StartQualifierClosed)))
 561                 n += len(x.StartQualifierClosed)
 562         case *ColumnRange_StartQualifierOpen:
 563                 n += proto.SizeVarint(3<<3 | proto.WireBytes)
 564                 n += proto.SizeVarint(uint64(len(x.StartQualifierOpen)))
 565                 n += len(x.StartQualifierOpen)
 566         case nil:
 567         default:
 568                 panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
 569         }
 570         // end_qualifier
 571         switch x := m.EndQualifier.(type) {
 572         case *ColumnRange_EndQualifierClosed:
 573                 n += proto.SizeVarint(4<<3 | proto.WireBytes)
 574                 n += proto.SizeVarint(uint64(len(x.EndQualifierClosed)))
 575                 n += len(x.EndQualifierClosed)
 576         case *ColumnRange_EndQualifierOpen:
 577                 n += proto.SizeVarint(5<<3 | proto.WireBytes)
 578                 n += proto.SizeVarint(uint64(len(x.EndQualifierOpen)))
 579                 n += len(x.EndQualifierOpen)
 580         case nil:
 581         default:
 582                 panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
 583         }
 584         return n
 585 }
 586
 587 // Specified a contiguous range of microsecond timestamps.
 588 type TimestampRange struct {
 589         // Inclusive lower bound. If left empty, interpreted as 0.
 590         StartTimestampMicros int64 `protobuf:"varint,1,opt,name=start_timestamp_micros,json=startTimestampMicros" json:"start_timestamp_micros,omitempty"`
 591         // Exclusive upper bound. If left empty, interpreted as infinity.
 592         EndTimestampMicros int64 `protobuf:"varint,2,opt,name=end_timestamp_micros,json=endTimestampMicros" json:"end_timestamp_micros,omitempty"`
 593 }
 594
 595 func (m *TimestampRange) Reset()                    { *m = TimestampRange{} }
 596 func (m *TimestampRange) String() string            { return proto.CompactTextString(m) }
 597 func (*TimestampRange) ProtoMessage()               {}
 598 func (*TimestampRange) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{7} }
 599
 600 func (m *TimestampRange) GetStartTimestampMicros() int64 {
 601         if m != nil {
 602                 return m.StartTimestampMicros
 603         }
 604         return 0
 605 }
 606
 607 func (m *TimestampRange) GetEndTimestampMicros() int64 {
 608         if m != nil {
 609                 return m.EndTimestampMicros
 610         }
 611         return 0
 612 }
 613
 614 // Specifies a contiguous range of raw byte values.
 615 type ValueRange struct {
 616         // The value at which to start the range.
 617         // If neither field is set, interpreted as the empty string, inclusive.
 618         //
 619         // Types that are valid to be assigned to StartValue:
 620         //      *ValueRange_StartValueClosed
 621         //      *ValueRange_StartValueOpen
 622         StartValue isValueRange_StartValue `protobuf_oneof:"start_value"`
 623         // The value at which to end the range.
 624         // If neither field is set, interpreted as the infinite string, exclusive.
 625         //
 626         // Types that are valid to be assigned to EndValue:
 627         //      *ValueRange_EndValueClosed
 628         //      *ValueRange_EndValueOpen
 629         EndValue isValueRange_EndValue `protobuf_oneof:"end_value"`
 630 }
 631
 632 func (m *ValueRange) Reset()                    { *m = ValueRange{} }
 633 func (m *ValueRange) String() string            { return proto.CompactTextString(m) }
 634 func (*ValueRange) ProtoMessage()               {}
 635 func (*ValueRange) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{8} }
 636
 637 type isValueRange_StartValue interface {
 638         isValueRange_StartValue()
 639 }
 640 type isValueRange_EndValue interface {
 641         isValueRange_EndValue()
 642 }
 643
 644 type ValueRange_StartValueClosed struct {
 645         StartValueClosed []byte `protobuf:"bytes,1,opt,name=start_value_closed,json=startValueClosed,proto3,oneof"`
 646 }
 647 type ValueRange_StartValueOpen struct {
 648         StartValueOpen []byte `protobuf:"bytes,2,opt,name=start_value_open,json=startValueOpen,proto3,oneof"`
 649 }
 650 type ValueRange_EndValueClosed struct {
 651         EndValueClosed []byte `protobuf:"bytes,3,opt,name=end_value_closed,json=endValueClosed,proto3,oneof"`
 652 }
 653 type ValueRange_EndValueOpen struct {
 654         EndValueOpen []byte `protobuf:"bytes,4,opt,name=end_value_open,json=endValueOpen,proto3,oneof"`
 655 }
 656
 657 func (*ValueRange_StartValueClosed) isValueRange_StartValue() {}
 658 func (*ValueRange_StartValueOpen) isValueRange_StartValue()   {}
 659 func (*ValueRange_EndValueClosed) isValueRange_EndValue()     {}
 660 func (*ValueRange_EndValueOpen) isValueRange_EndValue()       {}
 661
 662 func (m *ValueRange) GetStartValue() isValueRange_StartValue {
 663         if m != nil {
 664                 return m.StartValue
 665         }
 666         return nil
 667 }
 668 func (m *ValueRange) GetEndValue() isValueRange_EndValue {
 669         if m != nil {
 670                 return m.EndValue
 671         }
 672         return nil
 673 }
 674
 675 func (m *ValueRange) GetStartValueClosed() []byte {
 676         if x, ok := m.GetStartValue().(*ValueRange_StartValueClosed); ok {
 677                 return x.StartValueClosed
 678         }
 679         return nil
 680 }
 681
 682 func (m *ValueRange) GetStartValueOpen() []byte {
 683         if x, ok := m.GetStartValue().(*ValueRange_StartValueOpen); ok {
 684                 return x.StartValueOpen
 685         }
 686         return nil
 687 }
 688
 689 func (m *ValueRange) GetEndValueClosed() []byte {
 690         if x, ok := m.GetEndValue().(*ValueRange_EndValueClosed); ok {
 691                 return x.EndValueClosed
 692         }
 693         return nil
 694 }
 695
 696 func (m *ValueRange) GetEndValueOpen() []byte {
 697         if x, ok := m.GetEndValue().(*ValueRange_EndValueOpen); ok {
 698                 return x.EndValueOpen
 699         }
 700         return nil
 701 }
 702
 703 // XXX_OneofFuncs is for the internal use of the proto package.
 704 func (*ValueRange) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
 705         return _ValueRange_OneofMarshaler, _ValueRange_OneofUnmarshaler, _ValueRange_OneofSizer, []interface{}{
 706                 (*ValueRange_StartValueClosed)(nil),
 707                 (*ValueRange_StartValueOpen)(nil),
 708                 (*ValueRange_EndValueClosed)(nil),
 709                 (*ValueRange_EndValueOpen)(nil),
 710         }
 711 }
 712
 713 func _ValueRange_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
 714         m := msg.(*ValueRange)
 715         // start_value
 716         switch x := m.StartValue.(type) {
 717         case *ValueRange_StartValueClosed:
 718                 b.EncodeVarint(1<<3 | proto.WireBytes)
 719                 b.EncodeRawBytes(x.StartValueClosed)
 720         case *ValueRange_StartValueOpen:
 721                 b.EncodeVarint(2<<3 | proto.WireBytes)
 722                 b.EncodeRawBytes(x.StartValueOpen)
 723         case nil:
 724         default:
 725                 return fmt.Errorf("ValueRange.StartValue has unexpected type %T", x)
 726         }
 727         // end_value
 728         switch x := m.EndValue.(type) {
 729         case *ValueRange_EndValueClosed:
 730                 b.EncodeVarint(3<<3 | proto.WireBytes)
 731                 b.EncodeRawBytes(x.EndValueClosed)
 732         case *ValueRange_EndValueOpen:
 733                 b.EncodeVarint(4<<3 | proto.WireBytes)
 734                 b.EncodeRawBytes(x.EndValueOpen)
 735         case nil:
 736         default:
 737                 return fmt.Errorf("ValueRange.EndValue has unexpected type %T", x)
 738         }
 739         return nil
 740 }
 741
 742 func _ValueRange_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
 743         m := msg.(*ValueRange)
 744         switch tag {
 745         case 1: // start_value.start_value_closed
 746                 if wire != proto.WireBytes {
 747                         return true, proto.ErrInternalBadWireType
 748                 }
 749                 x, err := b.DecodeRawBytes(true)
 750                 m.StartValue = &ValueRange_StartValueClosed{x}
 751                 return true, err
 752         case 2: // start_value.start_value_open
 753                 if wire != proto.WireBytes {
 754                         return true, proto.ErrInternalBadWireType
 755                 }
 756                 x, err := b.DecodeRawBytes(true)
 757                 m.StartValue = &ValueRange_StartValueOpen{x}
 758                 return true, err
 759         case 3: // end_value.end_value_closed
 760                 if wire != proto.WireBytes {
 761                         return true, proto.ErrInternalBadWireType
 762                 }
 763                 x, err := b.DecodeRawBytes(true)
 764                 m.EndValue = &ValueRange_EndValueClosed{x}
 765                 return true, err
 766         case 4: // end_value.end_value_open
 767                 if wire != proto.WireBytes {
 768                         return true, proto.ErrInternalBadWireType
 769                 }
 770                 x, err := b.DecodeRawBytes(true)
 771                 m.EndValue = &ValueRange_EndValueOpen{x}
 772                 return true, err
 773         default:
 774                 return false, nil
 775         }
 776 }
 777
 778 func _ValueRange_OneofSizer(msg proto.Message) (n int) {
 779         m := msg.(*ValueRange)
 780         // start_value
 781         switch x := m.StartValue.(type) {
 782         case *ValueRange_StartValueClosed:
 783                 n += proto.SizeVarint(1<<3 | proto.WireBytes)
 784                 n += proto.SizeVarint(uint64(len(x.StartValueClosed)))
 785                 n += len(x.StartValueClosed)
 786         case *ValueRange_StartValueOpen:
 787                 n += proto.SizeVarint(2<<3 | proto.WireBytes)
 788                 n += proto.SizeVarint(uint64(len(x.StartValueOpen)))
 789                 n += len(x.StartValueOpen)
 790         case nil:
 791         default:
 792                 panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
 793         }
 794         // end_value
 795         switch x := m.EndValue.(type) {
 796         case *ValueRange_EndValueClosed:
 797                 n += proto.SizeVarint(3<<3 | proto.WireBytes)
 798                 n += proto.SizeVarint(uint64(len(x.EndValueClosed)))
 799                 n += len(x.EndValueClosed)
 800         case *ValueRange_EndValueOpen:
 801                 n += proto.SizeVarint(4<<3 | proto.WireBytes)
 802                 n += proto.SizeVarint(uint64(len(x.EndValueOpen)))
 803                 n += len(x.EndValueOpen)
 804         case nil:
 805         default:
 806                 panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
 807         }
 808         return n
 809 }
 810
 811 // Takes a row as input and produces an alternate view of the row based on
 812 // specified rules. For example, a RowFilter might trim down a row to include
 813 // just the cells from columns matching a given regular expression, or might
 814 // return all the cells of a row but not their values. More complicated filters
 815 // can be composed out of these components to express requests such as, "within
 816 // every column of a particular family, give just the two most recent cells
 817 // which are older than timestamp X."
 818 //
 819 // There are two broad categories of RowFilters (true filters and transformers),
 820 // as well as two ways to compose simple filters into more complex ones
 821 // (chains and interleaves). They work as follows:
 822 //
 823 // * True filters alter the input row by excluding some of its cells wholesale
 824 // from the output row. An example of a true filter is the `value_regex_filter`,
 825 // which excludes cells whose values don't match the specified pattern. All
 826 // regex true filters use RE2 syntax (https://github.com/google/re2/wiki/Syntax)
 827 // in raw byte mode (RE2::Latin1), and are evaluated as full matches. An
 828 // important point to keep in mind is that `RE2(.)` is equivalent by default to
 829 // `RE2([^\n])`, meaning that it does not match newlines. When attempting to
 830 // match an arbitrary byte, you should therefore use the escape sequence `\C`,
 831 // which may need to be further escaped as `\\C` in your client language.
 832 //
 833 // * Transformers alter the input row by changing the values of some of its
 834 // cells in the output, without excluding them completely. Currently, the only
 835 // supported transformer is the `strip_value_transformer`, which replaces every
 836 // cell's value with the empty string.
 837 //
 838 // * Chains and interleaves are described in more detail in the
 839 // RowFilter.Chain and RowFilter.Interleave documentation.
 840 //
 841 // The total serialized size of a RowFilter message must not
 842 // exceed 4096 bytes, and RowFilters may not be nested within each other
 843 // (in Chains or Interleaves) to a depth of more than 20.
 844 type RowFilter struct {
 845         // Which of the possible RowFilter types to apply. If none are set, this
 846         // RowFilter returns all cells in the input row.
 847         //
 848         // Types that are valid to be assigned to Filter:
 849         //      *RowFilter_Chain_
 850         //      *RowFilter_Interleave_
 851         //      *RowFilter_Condition_
 852         //      *RowFilter_Sink
 853         //      *RowFilter_PassAllFilter
 854         //      *RowFilter_BlockAllFilter
 855         //      *RowFilter_RowKeyRegexFilter
 856         //      *RowFilter_RowSampleFilter
 857         //      *RowFilter_FamilyNameRegexFilter
 858         //      *RowFilter_ColumnQualifierRegexFilter
 859         //      *RowFilter_ColumnRangeFilter
 860         //      *RowFilter_TimestampRangeFilter
 861         //      *RowFilter_ValueRegexFilter
 862         //      *RowFilter_ValueRangeFilter
 863         //      *RowFilter_CellsPerRowOffsetFilter
 864         //      *RowFilter_CellsPerRowLimitFilter
 865         //      *RowFilter_CellsPerColumnLimitFilter
 866         //      *RowFilter_StripValueTransformer
 867         //      *RowFilter_ApplyLabelTransformer
 868         Filter isRowFilter_Filter `protobuf_oneof:"filter"`
 869 }
 870
 871 func (m *RowFilter) Reset()                    { *m = RowFilter{} }
 872 func (m *RowFilter) String() string            { return proto.CompactTextString(m) }
 873 func (*RowFilter) ProtoMessage()               {}
 874 func (*RowFilter) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{9} }
 875
 876 type isRowFilter_Filter interface {
 877         isRowFilter_Filter()
 878 }
 879
 880 type RowFilter_Chain_ struct {
 881         Chain *RowFilter_Chain `protobuf:"bytes,1,opt,name=chain,oneof"`
 882 }
 883 type RowFilter_Interleave_ struct {
 884         Interleave *RowFilter_Interleave `protobuf:"bytes,2,opt,name=interleave,oneof"`
 885 }
 886 type RowFilter_Condition_ struct {
 887         Condition *RowFilter_Condition `protobuf:"bytes,3,opt,name=condition,oneof"`
 888 }
 889 type RowFilter_Sink struct {
 890         Sink bool `protobuf:"varint,16,opt,name=sink,oneof"`
 891 }
 892 type RowFilter_PassAllFilter struct {
 893         PassAllFilter bool `protobuf:"varint,17,opt,name=pass_all_filter,json=passAllFilter,oneof"`
 894 }
 895 type RowFilter_BlockAllFilter struct {
 896         BlockAllFilter bool `protobuf:"varint,18,opt,name=block_all_filter,json=blockAllFilter,oneof"`
 897 }
 898 type RowFilter_RowKeyRegexFilter struct {
 899         RowKeyRegexFilter []byte `protobuf:"bytes,4,opt,name=row_key_regex_filter,json=rowKeyRegexFilter,proto3,oneof"`
 900 }
 901 type RowFilter_RowSampleFilter struct {
 902         RowSampleFilter float64 `protobuf:"fixed64,14,opt,name=row_sample_filter,json=rowSampleFilter,oneof"`
 903 }
 904 type RowFilter_FamilyNameRegexFilter struct {
 905         FamilyNameRegexFilter string `protobuf:"bytes,5,opt,name=family_name_regex_filter,json=familyNameRegexFilter,oneof"`
 906 }
 907 type RowFilter_ColumnQualifierRegexFilter struct {
 908         ColumnQualifierRegexFilter []byte `protobuf:"bytes,6,opt,name=column_qualifier_regex_filter,json=columnQualifierRegexFilter,proto3,oneof"`
 909 }
 910 type RowFilter_ColumnRangeFilter struct {
 911         ColumnRangeFilter *ColumnRange `protobuf:"bytes,7,opt,name=column_range_filter,json=columnRangeFilter,oneof"`
 912 }
 913 type RowFilter_TimestampRangeFilter struct {
 914         TimestampRangeFilter *TimestampRange `protobuf:"bytes,8,opt,name=timestamp_range_filter,json=timestampRangeFilter,oneof"`
 915 }
 916 type RowFilter_ValueRegexFilter struct {
 917         ValueRegexFilter []byte `protobuf:"bytes,9,opt,name=value_regex_filter,json=valueRegexFilter,proto3,oneof"`
 918 }
 919 type RowFilter_ValueRangeFilter struct {
 920         ValueRangeFilter *ValueRange `protobuf:"bytes,15,opt,name=value_range_filter,json=valueRangeFilter,oneof"`
 921 }
 922 type RowFilter_CellsPerRowOffsetFilter struct {
 923         CellsPerRowOffsetFilter int32 `protobuf:"varint,10,opt,name=cells_per_row_offset_filter,json=cellsPerRowOffsetFilter,oneof"`
 924 }
 925 type RowFilter_CellsPerRowLimitFilter struct {
 926         CellsPerRowLimitFilter int32 `protobuf:"varint,11,opt,name=cells_per_row_limit_filter,json=cellsPerRowLimitFilter,oneof"`
 927 }
 928 type RowFilter_CellsPerColumnLimitFilter struct {
 929         CellsPerColumnLimitFilter int32 `protobuf:"varint,12,opt,name=cells_per_column_limit_filter,json=cellsPerColumnLimitFilter,oneof"`
 930 }
 931 type RowFilter_StripValueTransformer struct {
 932         StripValueTransformer bool `protobuf:"varint,13,opt,name=strip_value_transformer,json=stripValueTransformer,oneof"`
 933 }
 934 type RowFilter_ApplyLabelTransformer struct {
 935         ApplyLabelTransformer string `protobuf:"bytes,19,opt,name=apply_label_transformer,json=applyLabelTransformer,oneof"`
 936 }
 937
 938 func (*RowFilter_Chain_) isRowFilter_Filter()                     {}
 939 func (*RowFilter_Interleave_) isRowFilter_Filter()                {}
 940 func (*RowFilter_Condition_) isRowFilter_Filter()                 {}
 941 func (*RowFilter_Sink) isRowFilter_Filter()                       {}
 942 func (*RowFilter_PassAllFilter) isRowFilter_Filter()              {}
 943 func (*RowFilter_BlockAllFilter) isRowFilter_Filter()             {}
 944 func (*RowFilter_RowKeyRegexFilter) isRowFilter_Filter()          {}
 945 func (*RowFilter_RowSampleFilter) isRowFilter_Filter()            {}
 946 func (*RowFilter_FamilyNameRegexFilter) isRowFilter_Filter()      {}
 947 func (*RowFilter_ColumnQualifierRegexFilter) isRowFilter_Filter() {}
 948 func (*RowFilter_ColumnRangeFilter) isRowFilter_Filter()          {}
 949 func (*RowFilter_TimestampRangeFilter) isRowFilter_Filter()       {}
 950 func (*RowFilter_ValueRegexFilter) isRowFilter_Filter()           {}
 951 func (*RowFilter_ValueRangeFilter) isRowFilter_Filter()           {}
 952 func (*RowFilter_CellsPerRowOffsetFilter) isRowFilter_Filter()    {}
 953 func (*RowFilter_CellsPerRowLimitFilter) isRowFilter_Filter()     {}
 954 func (*RowFilter_CellsPerColumnLimitFilter) isRowFilter_Filter()  {}
 955 func (*RowFilter_StripValueTransformer) isRowFilter_Filter()      {}
 956 func (*RowFilter_ApplyLabelTransformer) isRowFilter_Filter()      {}
 957
 958 func (m *RowFilter) GetFilter() isRowFilter_Filter {
 959         if m != nil {
 960                 return m.Filter
 961         }
 962         return nil
 963 }
 964
 965 func (m *RowFilter) GetChain() *RowFilter_Chain {
 966         if x, ok := m.GetFilter().(*RowFilter_Chain_); ok {
 967                 return x.Chain
 968         }
 969         return nil
 970 }
 971
 972 func (m *RowFilter) GetInterleave() *RowFilter_Interleave {
 973         if x, ok := m.GetFilter().(*RowFilter_Interleave_); ok {
 974                 return x.Interleave
 975         }
 976         return nil
 977 }
 978
 979 func (m *RowFilter) GetCondition() *RowFilter_Condition {
 980         if x, ok := m.GetFilter().(*RowFilter_Condition_); ok {
 981                 return x.Condition
 982         }
 983         return nil
 984 }
 985
 986 func (m *RowFilter) GetSink() bool {
 987         if x, ok := m.GetFilter().(*RowFilter_Sink); ok {
 988                 return x.Sink
 989         }
 990         return false
 991 }
 992
 993 func (m *RowFilter) GetPassAllFilter() bool {
 994         if x, ok := m.GetFilter().(*RowFilter_PassAllFilter); ok {
 995                 return x.PassAllFilter
 996         }
 997         return false
 998 }
 999
1000 func (m *RowFilter) GetBlockAllFilter() bool {
1001         if x, ok := m.GetFilter().(*RowFilter_BlockAllFilter); ok {
1002                 return x.BlockAllFilter
1003         }
1004         return false
1005 }
1006
1007 func (m *RowFilter) GetRowKeyRegexFilter() []byte {
1008         if x, ok := m.GetFilter().(*RowFilter_RowKeyRegexFilter); ok {
1009                 return x.RowKeyRegexFilter
1010         }
1011         return nil
1012 }
1013
1014 func (m *RowFilter) GetRowSampleFilter() float64 {
1015         if x, ok := m.GetFilter().(*RowFilter_RowSampleFilter); ok {
1016                 return x.RowSampleFilter
1017         }
1018         return 0
1019 }
1020
1021 func (m *RowFilter) GetFamilyNameRegexFilter() string {
1022         if x, ok := m.GetFilter().(*RowFilter_FamilyNameRegexFilter); ok {
1023                 return x.FamilyNameRegexFilter
1024         }
1025         return ""
1026 }
1027
1028 func (m *RowFilter) GetColumnQualifierRegexFilter() []byte {
1029         if x, ok := m.GetFilter().(*RowFilter_ColumnQualifierRegexFilter); ok {
1030                 return x.ColumnQualifierRegexFilter
1031         }
1032         return nil
1033 }
1034
1035 func (m *RowFilter) GetColumnRangeFilter() *ColumnRange {
1036         if x, ok := m.GetFilter().(*RowFilter_ColumnRangeFilter); ok {
1037                 return x.ColumnRangeFilter
1038         }
1039         return nil
1040 }
1041
1042 func (m *RowFilter) GetTimestampRangeFilter() *TimestampRange {
1043         if x, ok := m.GetFilter().(*RowFilter_TimestampRangeFilter); ok {
1044                 return x.TimestampRangeFilter
1045         }
1046         return nil
1047 }
1048
1049 func (m *RowFilter) GetValueRegexFilter() []byte {
1050         if x, ok := m.GetFilter().(*RowFilter_ValueRegexFilter); ok {
1051                 return x.ValueRegexFilter
1052         }
1053         return nil
1054 }
1055
1056 func (m *RowFilter) GetValueRangeFilter() *ValueRange {
1057         if x, ok := m.GetFilter().(*RowFilter_ValueRangeFilter); ok {
1058                 return x.ValueRangeFilter
1059         }
1060         return nil
1061 }
1062
1063 func (m *RowFilter) GetCellsPerRowOffsetFilter() int32 {
1064         if x, ok := m.GetFilter().(*RowFilter_CellsPerRowOffsetFilter); ok {
1065                 return x.CellsPerRowOffsetFilter
1066         }
1067         return 0
1068 }
1069
1070 func (m *RowFilter) GetCellsPerRowLimitFilter() int32 {
1071         if x, ok := m.GetFilter().(*RowFilter_CellsPerRowLimitFilter); ok {
1072                 return x.CellsPerRowLimitFilter
1073         }
1074         return 0
1075 }
1076
1077 func (m *RowFilter) GetCellsPerColumnLimitFilter() int32 {
1078         if x, ok := m.GetFilter().(*RowFilter_CellsPerColumnLimitFilter); ok {
1079                 return x.CellsPerColumnLimitFilter
1080         }
1081         return 0
1082 }
1083
1084 func (m *RowFilter) GetStripValueTransformer() bool {
1085         if x, ok := m.GetFilter().(*RowFilter_StripValueTransformer); ok {
1086                 return x.StripValueTransformer
1087         }
1088         return false
1089 }
1090
1091 func (m *RowFilter) GetApplyLabelTransformer() string {
1092         if x, ok := m.GetFilter().(*RowFilter_ApplyLabelTransformer); ok {
1093                 return x.ApplyLabelTransformer
1094         }
1095         return ""
1096 }
1097
1098 // XXX_OneofFuncs is for the internal use of the proto package.
1099 func (*RowFilter) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
1100         return _RowFilter_OneofMarshaler, _RowFilter_OneofUnmarshaler, _RowFilter_OneofSizer, []interface{}{
1101                 (*RowFilter_Chain_)(nil),
1102                 (*RowFilter_Interleave_)(nil),
1103                 (*RowFilter_Condition_)(nil),
1104                 (*RowFilter_Sink)(nil),
1105                 (*RowFilter_PassAllFilter)(nil),
1106                 (*RowFilter_BlockAllFilter)(nil),
1107                 (*RowFilter_RowKeyRegexFilter)(nil),
1108                 (*RowFilter_RowSampleFilter)(nil),
1109                 (*RowFilter_FamilyNameRegexFilter)(nil),
1110                 (*RowFilter_ColumnQualifierRegexFilter)(nil),
1111                 (*RowFilter_ColumnRangeFilter)(nil),
1112                 (*RowFilter_TimestampRangeFilter)(nil),
1113                 (*RowFilter_ValueRegexFilter)(nil),
1114                 (*RowFilter_ValueRangeFilter)(nil),
1115                 (*RowFilter_CellsPerRowOffsetFilter)(nil),
1116                 (*RowFilter_CellsPerRowLimitFilter)(nil),
1117                 (*RowFilter_CellsPerColumnLimitFilter)(nil),
1118                 (*RowFilter_StripValueTransformer)(nil),
1119                 (*RowFilter_ApplyLabelTransformer)(nil),
1120         }
1121 }
1122
1123 func _RowFilter_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
1124         m := msg.(*RowFilter)
1125         // filter
1126         switch x := m.Filter.(type) {
1127         case *RowFilter_Chain_:
1128                 b.EncodeVarint(1<<3 | proto.WireBytes)
1129                 if err := b.EncodeMessage(x.Chain); err != nil {
1130                         return err
1131                 }
1132         case *RowFilter_Interleave_:
1133                 b.EncodeVarint(2<<3 | proto.WireBytes)
1134                 if err := b.EncodeMessage(x.Interleave); err != nil {
1135                         return err
1136                 }
1137         case *RowFilter_Condition_:
1138                 b.EncodeVarint(3<<3 | proto.WireBytes)
1139                 if err := b.EncodeMessage(x.Condition); err != nil {
1140                         return err
1141                 }
1142         case *RowFilter_Sink:
1143                 t := uint64(0)
1144                 if x.Sink {
1145                         t = 1
1146                 }
1147                 b.EncodeVarint(16<<3 | proto.WireVarint)
1148                 b.EncodeVarint(t)
1149         case *RowFilter_PassAllFilter:
1150                 t := uint64(0)
1151                 if x.PassAllFilter {
1152                         t = 1
1153                 }
1154                 b.EncodeVarint(17<<3 | proto.WireVarint)
1155                 b.EncodeVarint(t)
1156         case *RowFilter_BlockAllFilter:
1157                 t := uint64(0)
1158                 if x.BlockAllFilter {
1159                         t = 1
1160                 }
1161                 b.EncodeVarint(18<<3 | proto.WireVarint)
1162                 b.EncodeVarint(t)
1163         case *RowFilter_RowKeyRegexFilter:
1164                 b.EncodeVarint(4<<3 | proto.WireBytes)
1165                 b.EncodeRawBytes(x.RowKeyRegexFilter)
1166         case *RowFilter_RowSampleFilter:
1167                 b.EncodeVarint(14<<3 | proto.WireFixed64)
1168                 b.EncodeFixed64(math.Float64bits(x.RowSampleFilter))
1169         case *RowFilter_FamilyNameRegexFilter:
1170                 b.EncodeVarint(5<<3 | proto.WireBytes)
1171                 b.EncodeStringBytes(x.FamilyNameRegexFilter)
1172         case *RowFilter_ColumnQualifierRegexFilter:
1173                 b.EncodeVarint(6<<3 | proto.WireBytes)
1174                 b.EncodeRawBytes(x.ColumnQualifierRegexFilter)
1175         case *RowFilter_ColumnRangeFilter:
1176                 b.EncodeVarint(7<<3 | proto.WireBytes)
1177                 if err := b.EncodeMessage(x.ColumnRangeFilter); err != nil {
1178                         return err
1179                 }
1180         case *RowFilter_TimestampRangeFilter:
1181                 b.EncodeVarint(8<<3 | proto.WireBytes)
1182                 if err := b.EncodeMessage(x.TimestampRangeFilter); err != nil {
1183                         return err
1184                 }
1185         case *RowFilter_ValueRegexFilter:
1186                 b.EncodeVarint(9<<3 | proto.WireBytes)
1187                 b.EncodeRawBytes(x.ValueRegexFilter)
1188         case *RowFilter_ValueRangeFilter:
1189                 b.EncodeVarint(15<<3 | proto.WireBytes)
1190                 if err := b.EncodeMessage(x.ValueRangeFilter); err != nil {
1191                         return err
1192                 }
1193         case *RowFilter_CellsPerRowOffsetFilter:
1194                 b.EncodeVarint(10<<3 | proto.WireVarint)
1195                 b.EncodeVarint(uint64(x.CellsPerRowOffsetFilter))
1196         case *RowFilter_CellsPerRowLimitFilter:
1197                 b.EncodeVarint(11<<3 | proto.WireVarint)
1198                 b.EncodeVarint(uint64(x.CellsPerRowLimitFilter))
1199         case *RowFilter_CellsPerColumnLimitFilter:
1200                 b.EncodeVarint(12<<3 | proto.WireVarint)
1201                 b.EncodeVarint(uint64(x.CellsPerColumnLimitFilter))
1202         case *RowFilter_StripValueTransformer:
1203                 t := uint64(0)
1204                 if x.StripValueTransformer {
1205                         t = 1
1206                 }
1207                 b.EncodeVarint(13<<3 | proto.WireVarint)
1208                 b.EncodeVarint(t)
1209         case *RowFilter_ApplyLabelTransformer:
1210                 b.EncodeVarint(19<<3 | proto.WireBytes)
1211                 b.EncodeStringBytes(x.ApplyLabelTransformer)
1212         case nil:
1213         default:
1214                 return fmt.Errorf("RowFilter.Filter has unexpected type %T", x)
1215         }
1216         return nil
1217 }
1218
1219 func _RowFilter_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
1220         m := msg.(*RowFilter)
1221         switch tag {
1222         case 1: // filter.chain
1223                 if wire != proto.WireBytes {
1224                         return true, proto.ErrInternalBadWireType
1225                 }
1226                 msg := new(RowFilter_Chain)
1227                 err := b.DecodeMessage(msg)
1228                 m.Filter = &RowFilter_Chain_{msg}
1229                 return true, err
1230         case 2: // filter.interleave
1231                 if wire != proto.WireBytes {
1232                         return true, proto.ErrInternalBadWireType
1233                 }
1234                 msg := new(RowFilter_Interleave)
1235                 err := b.DecodeMessage(msg)
1236                 m.Filter = &RowFilter_Interleave_{msg}
1237                 return true, err
1238         case 3: // filter.condition
1239                 if wire != proto.WireBytes {
1240                         return true, proto.ErrInternalBadWireType
1241                 }
1242                 msg := new(RowFilter_Condition)
1243                 err := b.DecodeMessage(msg)
1244                 m.Filter = &RowFilter_Condition_{msg}
1245                 return true, err
1246         case 16: // filter.sink
1247                 if wire != proto.WireVarint {
1248                         return true, proto.ErrInternalBadWireType
1249                 }
1250                 x, err := b.DecodeVarint()
1251                 m.Filter = &RowFilter_Sink{x != 0}
1252                 return true, err
1253         case 17: // filter.pass_all_filter
1254                 if wire != proto.WireVarint {
1255                         return true, proto.ErrInternalBadWireType
1256                 }
1257                 x, err := b.DecodeVarint()
1258                 m.Filter = &RowFilter_PassAllFilter{x != 0}
1259                 return true, err
1260         case 18: // filter.block_all_filter
1261                 if wire != proto.WireVarint {
1262                         return true, proto.ErrInternalBadWireType
1263                 }
1264                 x, err := b.DecodeVarint()
1265                 m.Filter = &RowFilter_BlockAllFilter{x != 0}
1266                 return true, err
1267         case 4: // filter.row_key_regex_filter
1268                 if wire != proto.WireBytes {
1269                         return true, proto.ErrInternalBadWireType
1270                 }
1271                 x, err := b.DecodeRawBytes(true)
1272                 m.Filter = &RowFilter_RowKeyRegexFilter{x}
1273                 return true, err
1274         case 14: // filter.row_sample_filter
1275                 if wire != proto.WireFixed64 {
1276                         return true, proto.ErrInternalBadWireType
1277                 }
1278                 x, err := b.DecodeFixed64()
1279                 m.Filter = &RowFilter_RowSampleFilter{math.Float64frombits(x)}
1280                 return true, err
1281         case 5: // filter.family_name_regex_filter
1282                 if wire != proto.WireBytes {
1283                         return true, proto.ErrInternalBadWireType
1284                 }
1285                 x, err := b.DecodeStringBytes()
1286                 m.Filter = &RowFilter_FamilyNameRegexFilter{x}
1287                 return true, err
1288         case 6: // filter.column_qualifier_regex_filter
1289                 if wire != proto.WireBytes {
1290                         return true, proto.ErrInternalBadWireType
1291                 }
1292                 x, err := b.DecodeRawBytes(true)
1293                 m.Filter = &RowFilter_ColumnQualifierRegexFilter{x}
1294                 return true, err
1295         case 7: // filter.column_range_filter
1296                 if wire != proto.WireBytes {
1297                         return true, proto.ErrInternalBadWireType
1298                 }
1299                 msg := new(ColumnRange)
1300                 err := b.DecodeMessage(msg)
1301                 m.Filter = &RowFilter_ColumnRangeFilter{msg}
1302                 return true, err
1303         case 8: // filter.timestamp_range_filter
1304                 if wire != proto.WireBytes {
1305                         return true, proto.ErrInternalBadWireType
1306                 }
1307                 msg := new(TimestampRange)
1308                 err := b.DecodeMessage(msg)
1309                 m.Filter = &RowFilter_TimestampRangeFilter{msg}
1310                 return true, err
1311         case 9: // filter.value_regex_filter
1312                 if wire != proto.WireBytes {
1313                         return true, proto.ErrInternalBadWireType
1314                 }
1315                 x, err := b.DecodeRawBytes(true)
1316                 m.Filter = &RowFilter_ValueRegexFilter{x}
1317                 return true, err
1318         case 15: // filter.value_range_filter
1319                 if wire != proto.WireBytes {
1320                         return true, proto.ErrInternalBadWireType
1321                 }
1322                 msg := new(ValueRange)
1323                 err := b.DecodeMessage(msg)
1324                 m.Filter = &RowFilter_ValueRangeFilter{msg}
1325                 return true, err
1326         case 10: // filter.cells_per_row_offset_filter
1327                 if wire != proto.WireVarint {
1328                         return true, proto.ErrInternalBadWireType
1329                 }
1330                 x, err := b.DecodeVarint()
1331                 m.Filter = &RowFilter_CellsPerRowOffsetFilter{int32(x)}
1332                 return true, err
1333         case 11: // filter.cells_per_row_limit_filter
1334                 if wire != proto.WireVarint {
1335                         return true, proto.ErrInternalBadWireType
1336                 }
1337                 x, err := b.DecodeVarint()
1338                 m.Filter = &RowFilter_CellsPerRowLimitFilter{int32(x)}
1339                 return true, err
1340         case 12: // filter.cells_per_column_limit_filter
1341                 if wire != proto.WireVarint {
1342                         return true, proto.ErrInternalBadWireType
1343                 }
1344                 x, err := b.DecodeVarint()
1345                 m.Filter = &RowFilter_CellsPerColumnLimitFilter{int32(x)}
1346                 return true, err
1347         case 13: // filter.strip_value_transformer
1348                 if wire != proto.WireVarint {
1349                         return true, proto.ErrInternalBadWireType
1350                 }
1351                 x, err := b.DecodeVarint()
1352                 m.Filter = &RowFilter_StripValueTransformer{x != 0}
1353                 return true, err
1354         case 19: // filter.apply_label_transformer
1355                 if wire != proto.WireBytes {
1356                         return true, proto.ErrInternalBadWireType
1357                 }
1358                 x, err := b.DecodeStringBytes()
1359                 m.Filter = &RowFilter_ApplyLabelTransformer{x}
1360                 return true, err
1361         default:
1362                 return false, nil
1363         }
1364 }
1365
1366 func _RowFilter_OneofSizer(msg proto.Message) (n int) {
1367         m := msg.(*RowFilter)
1368         // filter
1369         switch x := m.Filter.(type) {
1370         case *RowFilter_Chain_:
1371                 s := proto.Size(x.Chain)
1372                 n += proto.SizeVarint(1<<3 | proto.WireBytes)
1373                 n += proto.SizeVarint(uint64(s))
1374                 n += s
1375         case *RowFilter_Interleave_:
1376                 s := proto.Size(x.Interleave)
1377                 n += proto.SizeVarint(2<<3 | proto.WireBytes)
1378                 n += proto.SizeVarint(uint64(s))
1379                 n += s
1380         case *RowFilter_Condition_:
1381                 s := proto.Size(x.Condition)
1382                 n += proto.SizeVarint(3<<3 | proto.WireBytes)
1383                 n += proto.SizeVarint(uint64(s))
1384                 n += s
1385         case *RowFilter_Sink:
1386                 n += proto.SizeVarint(16<<3 | proto.WireVarint)
1387                 n += 1
1388         case *RowFilter_PassAllFilter:
1389                 n += proto.SizeVarint(17<<3 | proto.WireVarint)
1390                 n += 1
1391         case *RowFilter_BlockAllFilter:
1392                 n += proto.SizeVarint(18<<3 | proto.WireVarint)
1393                 n += 1
1394         case *RowFilter_RowKeyRegexFilter:
1395                 n += proto.SizeVarint(4<<3 | proto.WireBytes)
1396                 n += proto.SizeVarint(uint64(len(x.RowKeyRegexFilter)))
1397                 n += len(x.RowKeyRegexFilter)
1398         case *RowFilter_RowSampleFilter:
1399                 n += proto.SizeVarint(14<<3 | proto.WireFixed64)
1400                 n += 8
1401         case *RowFilter_FamilyNameRegexFilter:
1402                 n += proto.SizeVarint(5<<3 | proto.WireBytes)
1403                 n += proto.SizeVarint(uint64(len(x.FamilyNameRegexFilter)))
1404                 n += len(x.FamilyNameRegexFilter)
1405         case *RowFilter_ColumnQualifierRegexFilter:
1406                 n += proto.SizeVarint(6<<3 | proto.WireBytes)
1407                 n += proto.SizeVarint(uint64(len(x.ColumnQualifierRegexFilter)))
1408                 n += len(x.ColumnQualifierRegexFilter)
1409         case *RowFilter_ColumnRangeFilter:
1410                 s := proto.Size(x.ColumnRangeFilter)
1411                 n += proto.SizeVarint(7<<3 | proto.WireBytes)
1412                 n += proto.SizeVarint(uint64(s))
1413                 n += s
1414         case *RowFilter_TimestampRangeFilter:
1415                 s := proto.Size(x.TimestampRangeFilter)
1416                 n += proto.SizeVarint(8<<3 | proto.WireBytes)
1417                 n += proto.SizeVarint(uint64(s))
1418                 n += s
1419         case *RowFilter_ValueRegexFilter:
1420                 n += proto.SizeVarint(9<<3 | proto.WireBytes)
1421                 n += proto.SizeVarint(uint64(len(x.ValueRegexFilter)))
1422                 n += len(x.ValueRegexFilter)
1423         case *RowFilter_ValueRangeFilter:
1424                 s := proto.Size(x.ValueRangeFilter)
1425                 n += proto.SizeVarint(15<<3 | proto.WireBytes)
1426                 n += proto.SizeVarint(uint64(s))
1427                 n += s
1428         case *RowFilter_CellsPerRowOffsetFilter:
1429                 n += proto.SizeVarint(10<<3 | proto.WireVarint)
1430                 n += proto.SizeVarint(uint64(x.CellsPerRowOffsetFilter))
1431         case *RowFilter_CellsPerRowLimitFilter:
1432                 n += proto.SizeVarint(11<<3 | proto.WireVarint)
1433                 n += proto.SizeVarint(uint64(x.CellsPerRowLimitFilter))
1434         case *RowFilter_CellsPerColumnLimitFilter:
1435                 n += proto.SizeVarint(12<<3 | proto.WireVarint)
1436                 n += proto.SizeVarint(uint64(x.CellsPerColumnLimitFilter))
1437         case *RowFilter_StripValueTransformer:
1438                 n += proto.SizeVarint(13<<3 | proto.WireVarint)
1439                 n += 1
1440         case *RowFilter_ApplyLabelTransformer:
1441                 n += proto.SizeVarint(19<<3 | proto.WireBytes)
1442                 n += proto.SizeVarint(uint64(len(x.ApplyLabelTransformer)))
1443                 n += len(x.ApplyLabelTransformer)
1444         case nil:
1445         default:
1446                 panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
1447         }
1448         return n
1449 }
1450
1451 // A RowFilter which sends rows through several RowFilters in sequence.
1452 type RowFilter_Chain struct {
1453         // The elements of "filters" are chained together to process the input row:
1454         // in row -> f(0) -> intermediate row -> f(1) -> ... -> f(N) -> out row
1455         // The full chain is executed atomically.
1456         Filters []*RowFilter `protobuf:"bytes,1,rep,name=filters" json:"filters,omitempty"`
1457 }
1458
1459 func (m *RowFilter_Chain) Reset()                    { *m = RowFilter_Chain{} }
1460 func (m *RowFilter_Chain) String() string            { return proto.CompactTextString(m) }
1461 func (*RowFilter_Chain) ProtoMessage()               {}
1462 func (*RowFilter_Chain) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{9, 0} }
1463
1464 func (m *RowFilter_Chain) GetFilters() []*RowFilter {
1465         if m != nil {
1466                 return m.Filters
1467         }
1468         return nil
1469 }
1470
1471 // A RowFilter which sends each row to each of several component
1472 // RowFilters and interleaves the results.
1473 type RowFilter_Interleave struct {
1474         // The elements of "filters" all process a copy of the input row, and the
1475         // results are pooled, sorted, and combined into a single output row.
1476         // If multiple cells are produced with the same column and timestamp,
1477         // they will all appear in the output row in an unspecified mutual order.
1478         // Consider the following example, with three filters:
1479         //
1480         //                                  input row
1481         //                                      |
1482         //            -----------------------------------------------------
1483         //            |                         |                         |
1484         //           f(0)                      f(1)                      f(2)
1485         //            |                         |                         |
1486         //     1: foo,bar,10,x             foo,bar,10,z              far,bar,7,a
1487         //     2: foo,blah,11,z            far,blah,5,x              far,blah,5,x
1488         //            |                         |                         |
1489         //            -----------------------------------------------------
1490         //                                      |
1491         //     1:                      foo,bar,10,z   // could have switched with #2
1492         //     2:                      foo,bar,10,x   // could have switched with #1
1493         //     3:                      foo,blah,11,z
1494         //     4:                      far,bar,7,a
1495         //     5:                      far,blah,5,x   // identical to #6
1496         //     6:                      far,blah,5,x   // identical to #5
1497         //
1498         // All interleaved filters are executed atomically.
1499         Filters []*RowFilter `protobuf:"bytes,1,rep,name=filters" json:"filters,omitempty"`
1500 }
1501
1502 func (m *RowFilter_Interleave) Reset()                    { *m = RowFilter_Interleave{} }
1503 func (m *RowFilter_Interleave) String() string            { return proto.CompactTextString(m) }
1504 func (*RowFilter_Interleave) ProtoMessage()               {}
1505 func (*RowFilter_Interleave) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{9, 1} }
1506
1507 func (m *RowFilter_Interleave) GetFilters() []*RowFilter {
1508         if m != nil {
1509                 return m.Filters
1510         }
1511         return nil
1512 }
1513
1514 // A RowFilter which evaluates one of two possible RowFilters, depending on
1515 // whether or not a predicate RowFilter outputs any cells from the input row.
1516 //
1517 // IMPORTANT NOTE: The predicate filter does not execute atomically with the
1518 // true and false filters, which may lead to inconsistent or unexpected
1519 // results. Additionally, Condition filters have poor performance, especially
1520 // when filters are set for the false condition.
1521 type RowFilter_Condition struct {
1522         // If `predicate_filter` outputs any cells, then `true_filter` will be
1523         // evaluated on the input row. Otherwise, `false_filter` will be evaluated.
1524         PredicateFilter *RowFilter `protobuf:"bytes,1,opt,name=predicate_filter,json=predicateFilter" json:"predicate_filter,omitempty"`
1525         // The filter to apply to the input row if `predicate_filter` returns any
1526         // results. If not provided, no results will be returned in the true case.
1527         TrueFilter *RowFilter `protobuf:"bytes,2,opt,name=true_filter,json=trueFilter" json:"true_filter,omitempty"`
1528         // The filter to apply to the input row if `predicate_filter` does not
1529         // return any results. If not provided, no results will be returned in the
1530         // false case.
1531         FalseFilter *RowFilter `protobuf:"bytes,3,opt,name=false_filter,json=falseFilter" json:"false_filter,omitempty"`
1532 }
1533
1534 func (m *RowFilter_Condition) Reset()                    { *m = RowFilter_Condition{} }
1535 func (m *RowFilter_Condition) String() string            { return proto.CompactTextString(m) }
1536 func (*RowFilter_Condition) ProtoMessage()               {}
1537 func (*RowFilter_Condition) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{9, 2} }
1538
1539 func (m *RowFilter_Condition) GetPredicateFilter() *RowFilter {
1540         if m != nil {
1541                 return m.PredicateFilter
1542         }
1543         return nil
1544 }
1545
1546 func (m *RowFilter_Condition) GetTrueFilter() *RowFilter {
1547         if m != nil {
1548                 return m.TrueFilter
1549         }
1550         return nil
1551 }
1552
1553 func (m *RowFilter_Condition) GetFalseFilter() *RowFilter {
1554         if m != nil {
1555                 return m.FalseFilter
1556         }
1557         return nil
1558 }
1559
1560 // Specifies a particular change to be made to the contents of a row.
1561 type Mutation struct {
1562         // Which of the possible Mutation types to apply.
1563         //
1564         // Types that are valid to be assigned to Mutation:
1565         //      *Mutation_SetCell_
1566         //      *Mutation_DeleteFromColumn_
1567         //      *Mutation_DeleteFromFamily_
1568         //      *Mutation_DeleteFromRow_
1569         Mutation isMutation_Mutation `protobuf_oneof:"mutation"`
1570 }
1571
1572 func (m *Mutation) Reset()                    { *m = Mutation{} }
1573 func (m *Mutation) String() string            { return proto.CompactTextString(m) }
1574 func (*Mutation) ProtoMessage()               {}
1575 func (*Mutation) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{10} }
1576
1577 type isMutation_Mutation interface {
1578         isMutation_Mutation()
1579 }
1580
1581 type Mutation_SetCell_ struct {
1582         SetCell *Mutation_SetCell `protobuf:"bytes,1,opt,name=set_cell,json=setCell,oneof"`
1583 }
1584 type Mutation_DeleteFromColumn_ struct {
1585         DeleteFromColumn *Mutation_DeleteFromColumn `protobuf:"bytes,2,opt,name=delete_from_column,json=deleteFromColumn,oneof"`
1586 }
1587 type Mutation_DeleteFromFamily_ struct {
1588         DeleteFromFamily *Mutation_DeleteFromFamily `protobuf:"bytes,3,opt,name=delete_from_family,json=deleteFromFamily,oneof"`
1589 }
1590 type Mutation_DeleteFromRow_ struct {
1591         DeleteFromRow *Mutation_DeleteFromRow `protobuf:"bytes,4,opt,name=delete_from_row,json=deleteFromRow,oneof"`
1592 }
1593
1594 func (*Mutation_SetCell_) isMutation_Mutation()          {}
1595 func (*Mutation_DeleteFromColumn_) isMutation_Mutation() {}
1596 func (*Mutation_DeleteFromFamily_) isMutation_Mutation() {}
1597 func (*Mutation_DeleteFromRow_) isMutation_Mutation()    {}
1598
1599 func (m *Mutation) GetMutation() isMutation_Mutation {
1600         if m != nil {
1601                 return m.Mutation
1602         }
1603         return nil
1604 }
1605
1606 func (m *Mutation) GetSetCell() *Mutation_SetCell {
1607         if x, ok := m.GetMutation().(*Mutation_SetCell_); ok {
1608                 return x.SetCell
1609         }
1610         return nil
1611 }
1612
1613 func (m *Mutation) GetDeleteFromColumn() *Mutation_DeleteFromColumn {
1614         if x, ok := m.GetMutation().(*Mutation_DeleteFromColumn_); ok {
1615                 return x.DeleteFromColumn
1616         }
1617         return nil
1618 }
1619
1620 func (m *Mutation) GetDeleteFromFamily() *Mutation_DeleteFromFamily {
1621         if x, ok := m.GetMutation().(*Mutation_DeleteFromFamily_); ok {
1622                 return x.DeleteFromFamily
1623         }
1624         return nil
1625 }
1626
1627 func (m *Mutation) GetDeleteFromRow() *Mutation_DeleteFromRow {
1628         if x, ok := m.GetMutation().(*Mutation_DeleteFromRow_); ok {
1629                 return x.DeleteFromRow
1630         }
1631         return nil
1632 }
1633
1634 // XXX_OneofFuncs is for the internal use of the proto package.
1635 func (*Mutation) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
1636         return _Mutation_OneofMarshaler, _Mutation_OneofUnmarshaler, _Mutation_OneofSizer, []interface{}{
1637                 (*Mutation_SetCell_)(nil),
1638                 (*Mutation_DeleteFromColumn_)(nil),
1639                 (*Mutation_DeleteFromFamily_)(nil),
1640                 (*Mutation_DeleteFromRow_)(nil),
1641         }
1642 }
1643
1644 func _Mutation_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
1645         m := msg.(*Mutation)
1646         // mutation
1647         switch x := m.Mutation.(type) {
1648         case *Mutation_SetCell_:
1649                 b.EncodeVarint(1<<3 | proto.WireBytes)
1650                 if err := b.EncodeMessage(x.SetCell); err != nil {
1651                         return err
1652                 }
1653         case *Mutation_DeleteFromColumn_:
1654                 b.EncodeVarint(2<<3 | proto.WireBytes)
1655                 if err := b.EncodeMessage(x.DeleteFromColumn); err != nil {
1656                         return err
1657                 }
1658         case *Mutation_DeleteFromFamily_:
1659                 b.EncodeVarint(3<<3 | proto.WireBytes)
1660                 if err := b.EncodeMessage(x.DeleteFromFamily); err != nil {
1661                         return err
1662                 }
1663         case *Mutation_DeleteFromRow_:
1664                 b.EncodeVarint(4<<3 | proto.WireBytes)
1665                 if err := b.EncodeMessage(x.DeleteFromRow); err != nil {
1666                         return err
1667                 }
1668         case nil:
1669         default:
1670                 return fmt.Errorf("Mutation.Mutation has unexpected type %T", x)
1671         }
1672         return nil
1673 }
1674
1675 func _Mutation_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
1676         m := msg.(*Mutation)
1677         switch tag {
1678         case 1: // mutation.set_cell
1679                 if wire != proto.WireBytes {
1680                         return true, proto.ErrInternalBadWireType
1681                 }
1682                 msg := new(Mutation_SetCell)
1683                 err := b.DecodeMessage(msg)
1684                 m.Mutation = &Mutation_SetCell_{msg}
1685                 return true, err
1686         case 2: // mutation.delete_from_column
1687                 if wire != proto.WireBytes {
1688                         return true, proto.ErrInternalBadWireType
1689                 }
1690                 msg := new(Mutation_DeleteFromColumn)
1691                 err := b.DecodeMessage(msg)
1692                 m.Mutation = &Mutation_DeleteFromColumn_{msg}
1693                 return true, err
1694         case 3: // mutation.delete_from_family
1695                 if wire != proto.WireBytes {
1696                         return true, proto.ErrInternalBadWireType
1697                 }
1698                 msg := new(Mutation_DeleteFromFamily)
1699                 err := b.DecodeMessage(msg)
1700                 m.Mutation = &Mutation_DeleteFromFamily_{msg}
1701                 return true, err
1702         case 4: // mutation.delete_from_row
1703                 if wire != proto.WireBytes {
1704                         return true, proto.ErrInternalBadWireType
1705                 }
1706                 msg := new(Mutation_DeleteFromRow)
1707                 err := b.DecodeMessage(msg)
1708                 m.Mutation = &Mutation_DeleteFromRow_{msg}
1709                 return true, err
1710         default:
1711                 return false, nil
1712         }
1713 }
1714
1715 func _Mutation_OneofSizer(msg proto.Message) (n int) {
1716         m := msg.(*Mutation)
1717         // mutation
1718         switch x := m.Mutation.(type) {
1719         case *Mutation_SetCell_:
1720                 s := proto.Size(x.SetCell)
1721                 n += proto.SizeVarint(1<<3 | proto.WireBytes)
1722                 n += proto.SizeVarint(uint64(s))
1723                 n += s
1724         case *Mutation_DeleteFromColumn_:
1725                 s := proto.Size(x.DeleteFromColumn)
1726                 n += proto.SizeVarint(2<<3 | proto.WireBytes)
1727                 n += proto.SizeVarint(uint64(s))
1728                 n += s
1729         case *Mutation_DeleteFromFamily_:
1730                 s := proto.Size(x.DeleteFromFamily)
1731                 n += proto.SizeVarint(3<<3 | proto.WireBytes)
1732                 n += proto.SizeVarint(uint64(s))
1733                 n += s
1734         case *Mutation_DeleteFromRow_:
1735                 s := proto.Size(x.DeleteFromRow)
1736                 n += proto.SizeVarint(4<<3 | proto.WireBytes)
1737                 n += proto.SizeVarint(uint64(s))
1738                 n += s
1739         case nil:
1740         default:
1741                 panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
1742         }
1743         return n
1744 }
1745
1746 // A Mutation which sets the value of the specified cell.
1747 type Mutation_SetCell struct {
1748         // The name of the family into which new data should be written.
1749         // Must match `[-_.a-zA-Z0-9]+`
1750         FamilyName string `protobuf:"bytes,1,opt,name=family_name,json=familyName" json:"family_name,omitempty"`
1751         // The qualifier of the column into which new data should be written.
1752         // Can be any byte string, including the empty string.
1753         ColumnQualifier []byte `protobuf:"bytes,2,opt,name=column_qualifier,json=columnQualifier,proto3" json:"column_qualifier,omitempty"`
1754         // The timestamp of the cell into which new data should be written.
1755         // Use -1 for current Bigtable server time.
1756         // Otherwise, the client should set this value itself, noting that the
1757         // default value is a timestamp of zero if the field is left unspecified.
1758         // Values must match the granularity of the table (e.g. micros, millis).
1759         TimestampMicros int64 `protobuf:"varint,3,opt,name=timestamp_micros,json=timestampMicros" json:"timestamp_micros,omitempty"`
1760         // The value to be written into the specified cell.
1761         Value []byte `protobuf:"bytes,4,opt,name=value,proto3" json:"value,omitempty"`
1762 }
1763
1764 func (m *Mutation_SetCell) Reset()                    { *m = Mutation_SetCell{} }
1765 func (m *Mutation_SetCell) String() string            { return proto.CompactTextString(m) }
1766 func (*Mutation_SetCell) ProtoMessage()               {}
1767 func (*Mutation_SetCell) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{10, 0} }
1768
1769 func (m *Mutation_SetCell) GetFamilyName() string {
1770         if m != nil {
1771                 return m.FamilyName
1772         }
1773         return ""
1774 }
1775
1776 func (m *Mutation_SetCell) GetColumnQualifier() []byte {
1777         if m != nil {
1778                 return m.ColumnQualifier
1779         }
1780         return nil
1781 }
1782
1783 func (m *Mutation_SetCell) GetTimestampMicros() int64 {
1784         if m != nil {
1785                 return m.TimestampMicros
1786         }
1787         return 0
1788 }
1789
1790 func (m *Mutation_SetCell) GetValue() []byte {
1791         if m != nil {
1792                 return m.Value
1793         }
1794         return nil
1795 }
1796
1797 // A Mutation which deletes cells from the specified column, optionally
1798 // restricting the deletions to a given timestamp range.
1799 type Mutation_DeleteFromColumn struct {
1800         // The name of the family from which cells should be deleted.
1801         // Must match `[-_.a-zA-Z0-9]+`
1802         FamilyName string `protobuf:"bytes,1,opt,name=family_name,json=familyName" json:"family_name,omitempty"`
1803         // The qualifier of the column from which cells should be deleted.
1804         // Can be any byte string, including the empty string.
1805         ColumnQualifier []byte `protobuf:"bytes,2,opt,name=column_qualifier,json=columnQualifier,proto3" json:"column_qualifier,omitempty"`
1806         // The range of timestamps within which cells should be deleted.
1807         TimeRange *TimestampRange `protobuf:"bytes,3,opt,name=time_range,json=timeRange" json:"time_range,omitempty"`
1808 }
1809
1810 func (m *Mutation_DeleteFromColumn) Reset()                    { *m = Mutation_DeleteFromColumn{} }
1811 func (m *Mutation_DeleteFromColumn) String() string            { return proto.CompactTextString(m) }
1812 func (*Mutation_DeleteFromColumn) ProtoMessage()               {}
1813 func (*Mutation_DeleteFromColumn) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{10, 1} }
1814
1815 func (m *Mutation_DeleteFromColumn) GetFamilyName() string {
1816         if m != nil {
1817                 return m.FamilyName
1818         }
1819         return ""
1820 }
1821
1822 func (m *Mutation_DeleteFromColumn) GetColumnQualifier() []byte {
1823         if m != nil {
1824                 return m.ColumnQualifier
1825         }
1826         return nil
1827 }
1828
1829 func (m *Mutation_DeleteFromColumn) GetTimeRange() *TimestampRange {
1830         if m != nil {
1831                 return m.TimeRange
1832         }
1833         return nil
1834 }
1835
1836 // A Mutation which deletes all cells from the specified column family.
1837 type Mutation_DeleteFromFamily struct {
1838         // The name of the family from which cells should be deleted.
1839         // Must match `[-_.a-zA-Z0-9]+`
1840         FamilyName string `protobuf:"bytes,1,opt,name=family_name,json=familyName" json:"family_name,omitempty"`
1841 }
1842
1843 func (m *Mutation_DeleteFromFamily) Reset()                    { *m = Mutation_DeleteFromFamily{} }
1844 func (m *Mutation_DeleteFromFamily) String() string            { return proto.CompactTextString(m) }
1845 func (*Mutation_DeleteFromFamily) ProtoMessage()               {}
1846 func (*Mutation_DeleteFromFamily) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{10, 2} }
1847
1848 func (m *Mutation_DeleteFromFamily) GetFamilyName() string {
1849         if m != nil {
1850                 return m.FamilyName
1851         }
1852         return ""
1853 }
1854
1855 // A Mutation which deletes all cells from the containing row.
1856 type Mutation_DeleteFromRow struct {
1857 }
1858
1859 func (m *Mutation_DeleteFromRow) Reset()                    { *m = Mutation_DeleteFromRow{} }
1860 func (m *Mutation_DeleteFromRow) String() string            { return proto.CompactTextString(m) }
1861 func (*Mutation_DeleteFromRow) ProtoMessage()               {}
1862 func (*Mutation_DeleteFromRow) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{10, 3} }
1863
1864 // Specifies an atomic read/modify/write operation on the latest value of the
1865 // specified column.
1866 type ReadModifyWriteRule struct {
1867         // The name of the family to which the read/modify/write should be applied.
1868         // Must match `[-_.a-zA-Z0-9]+`
1869         FamilyName string `protobuf:"bytes,1,opt,name=family_name,json=familyName" json:"family_name,omitempty"`
1870         // The qualifier of the column to which the read/modify/write should be
1871         // applied.
1872         // Can be any byte string, including the empty string.
1873         ColumnQualifier []byte `protobuf:"bytes,2,opt,name=column_qualifier,json=columnQualifier,proto3" json:"column_qualifier,omitempty"`
1874         // The rule used to determine the column's new latest value from its current
1875         // latest value.
1876         //
1877         // Types that are valid to be assigned to Rule:
1878         //      *ReadModifyWriteRule_AppendValue
1879         //      *ReadModifyWriteRule_IncrementAmount
1880         Rule isReadModifyWriteRule_Rule `protobuf_oneof:"rule"`
1881 }
1882
1883 func (m *ReadModifyWriteRule) Reset()                    { *m = ReadModifyWriteRule{} }
1884 func (m *ReadModifyWriteRule) String() string            { return proto.CompactTextString(m) }
1885 func (*ReadModifyWriteRule) ProtoMessage()               {}
1886 func (*ReadModifyWriteRule) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{11} }
1887
1888 type isReadModifyWriteRule_Rule interface {
1889         isReadModifyWriteRule_Rule()
1890 }
1891
1892 type ReadModifyWriteRule_AppendValue struct {
1893         AppendValue []byte `protobuf:"bytes,3,opt,name=append_value,json=appendValue,proto3,oneof"`
1894 }
1895 type ReadModifyWriteRule_IncrementAmount struct {
1896         IncrementAmount int64 `protobuf:"varint,4,opt,name=increment_amount,json=incrementAmount,oneof"`
1897 }
1898
1899 func (*ReadModifyWriteRule_AppendValue) isReadModifyWriteRule_Rule()     {}
1900 func (*ReadModifyWriteRule_IncrementAmount) isReadModifyWriteRule_Rule() {}
1901
1902 func (m *ReadModifyWriteRule) GetRule() isReadModifyWriteRule_Rule {
1903         if m != nil {
1904                 return m.Rule
1905         }
1906         return nil
1907 }
1908
1909 func (m *ReadModifyWriteRule) GetFamilyName() string {
1910         if m != nil {
1911                 return m.FamilyName
1912         }
1913         return ""
1914 }
1915
1916 func (m *ReadModifyWriteRule) GetColumnQualifier() []byte {
1917         if m != nil {
1918                 return m.ColumnQualifier
1919         }
1920         return nil
1921 }
1922
1923 func (m *ReadModifyWriteRule) GetAppendValue() []byte {
1924         if x, ok := m.GetRule().(*ReadModifyWriteRule_AppendValue); ok {
1925                 return x.AppendValue
1926         }
1927         return nil
1928 }
1929
1930 func (m *ReadModifyWriteRule) GetIncrementAmount() int64 {
1931         if x, ok := m.GetRule().(*ReadModifyWriteRule_IncrementAmount); ok {
1932                 return x.IncrementAmount
1933         }
1934         return 0
1935 }
1936
1937 // XXX_OneofFuncs is for the internal use of the proto package.
1938 func (*ReadModifyWriteRule) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
1939         return _ReadModifyWriteRule_OneofMarshaler, _ReadModifyWriteRule_OneofUnmarshaler, _ReadModifyWriteRule_OneofSizer, []interface{}{
1940                 (*ReadModifyWriteRule_AppendValue)(nil),
1941                 (*ReadModifyWriteRule_IncrementAmount)(nil),
1942         }
1943 }
1944
1945 func _ReadModifyWriteRule_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
1946         m := msg.(*ReadModifyWriteRule)
1947         // rule
1948         switch x := m.Rule.(type) {
1949         case *ReadModifyWriteRule_AppendValue:
1950                 b.EncodeVarint(3<<3 | proto.WireBytes)
1951                 b.EncodeRawBytes(x.AppendValue)
1952         case *ReadModifyWriteRule_IncrementAmount:
1953                 b.EncodeVarint(4<<3 | proto.WireVarint)
1954                 b.EncodeVarint(uint64(x.IncrementAmount))
1955         case nil:
1956         default:
1957                 return fmt.Errorf("ReadModifyWriteRule.Rule has unexpected type %T", x)
1958         }
1959         return nil
1960 }
1961
1962 func _ReadModifyWriteRule_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
1963         m := msg.(*ReadModifyWriteRule)
1964         switch tag {
1965         case 3: // rule.append_value
1966                 if wire != proto.WireBytes {
1967                         return true, proto.ErrInternalBadWireType
1968                 }
1969                 x, err := b.DecodeRawBytes(true)
1970                 m.Rule = &ReadModifyWriteRule_AppendValue{x}
1971                 return true, err
1972         case 4: // rule.increment_amount
1973                 if wire != proto.WireVarint {
1974                         return true, proto.ErrInternalBadWireType
1975                 }
1976                 x, err := b.DecodeVarint()
1977                 m.Rule = &ReadModifyWriteRule_IncrementAmount{int64(x)}
1978                 return true, err
1979         default:
1980                 return false, nil
1981         }
1982 }
1983
1984 func _ReadModifyWriteRule_OneofSizer(msg proto.Message) (n int) {
1985         m := msg.(*ReadModifyWriteRule)
1986         // rule
1987         switch x := m.Rule.(type) {
1988         case *ReadModifyWriteRule_AppendValue:
1989                 n += proto.SizeVarint(3<<3 | proto.WireBytes)
1990                 n += proto.SizeVarint(uint64(len(x.AppendValue)))
1991                 n += len(x.AppendValue)
1992         case *ReadModifyWriteRule_IncrementAmount:
1993                 n += proto.SizeVarint(4<<3 | proto.WireVarint)
1994                 n += proto.SizeVarint(uint64(x.IncrementAmount))
1995         case nil:
1996         default:
1997                 panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
1998         }
1999         return n
2000 }
2001
2002 func init() {
2003         proto.RegisterType((*Row)(nil), "google.bigtable.v2.Row")
2004         proto.RegisterType((*Family)(nil), "google.bigtable.v2.Family")
2005         proto.RegisterType((*Column)(nil), "google.bigtable.v2.Column")
2006         proto.RegisterType((*Cell)(nil), "google.bigtable.v2.Cell")
2007         proto.RegisterType((*RowRange)(nil), "google.bigtable.v2.RowRange")
2008         proto.RegisterType((*RowSet)(nil), "google.bigtable.v2.RowSet")
2009         proto.RegisterType((*ColumnRange)(nil), "google.bigtable.v2.ColumnRange")
2010         proto.RegisterType((*TimestampRange)(nil), "google.bigtable.v2.TimestampRange")
2011         proto.RegisterType((*ValueRange)(nil), "google.bigtable.v2.ValueRange")
2012         proto.RegisterType((*RowFilter)(nil), "google.bigtable.v2.RowFilter")
2013         proto.RegisterType((*RowFilter_Chain)(nil), "google.bigtable.v2.RowFilter.Chain")
2014         proto.RegisterType((*RowFilter_Interleave)(nil), "google.bigtable.v2.RowFilter.Interleave")
2015         proto.RegisterType((*RowFilter_Condition)(nil), "google.bigtable.v2.RowFilter.Condition")
2016         proto.RegisterType((*Mutation)(nil), "google.bigtable.v2.Mutation")
2017         proto.RegisterType((*Mutation_SetCell)(nil), "google.bigtable.v2.Mutation.SetCell")
2018         proto.RegisterType((*Mutation_DeleteFromColumn)(nil), "google.bigtable.v2.Mutation.DeleteFromColumn")
2019         proto.RegisterType((*Mutation_DeleteFromFamily)(nil), "google.bigtable.v2.Mutation.DeleteFromFamily")
2020         proto.RegisterType((*Mutation_DeleteFromRow)(nil), "google.bigtable.v2.Mutation.DeleteFromRow")
2021         proto.RegisterType((*ReadModifyWriteRule)(nil), "google.bigtable.v2.ReadModifyWriteRule")
2022 }
2023
2024 func init() { proto.RegisterFile("google/bigtable/v2/data.proto", fileDescriptor1) }
2025
2026 var fileDescriptor1 = []byte{
2027         // 1430 bytes of a gzipped FileDescriptorProto
2028         0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x57, 0xdd, 0x6e, 0x1b, 0x45,
2029         0x14, 0xf6, 0xc6, 0x89, 0x7f, 0xce, 0x3a, 0xb6, 0x3b, 0x4d, 0x53, 0xd7, 0x34, 0x34, 0xda, 0xa2,
2030         0xe2, 0x06, 0x70, 0xc0, 0xad, 0xca, 0x4f, 0x11, 0x6a, 0x9c, 0xd2, 0x1a, 0xfa, 0x3f, 0x8d, 0x8a,
2031         0x54, 0x09, 0x2d, 0x13, 0x7b, 0x6c, 0x56, 0x99, 0xdd, 0x59, 0x76, 0xd7, 0x71, 0x2d, 0xf1, 0x1c,
2032         0xdc, 0xc3, 0x25, 0xaf, 0xc0, 0x1d, 0x2f, 0x01, 0x8f, 0xc1, 0x03, 0x70, 0x81, 0xe6, 0x67, 0xff,
2033         0x5c, 0x37, 0x89, 0x50, 0xef, 0x76, 0xcf, 0xf9, 0xbe, 0xef, 0x9c, 0x39, 0x73, 0xe6, 0xec, 0x2c,
2034         0x6c, 0x4d, 0x38, 0x9f, 0x30, 0xba, 0x7b, 0xe8, 0x4c, 0x22, 0x72, 0xc8, 0xe8, 0xee, 0x71, 0x6f,
2035         0x77, 0x44, 0x22, 0xd2, 0xf5, 0x03, 0x1e, 0x71, 0x84, 0x94, 0xbb, 0x1b, 0xbb, 0xbb, 0xc7, 0x3d,
2036         0xeb, 0x09, 0x14, 0x31, 0x9f, 0xa1, 0x26, 0x14, 0x8f, 0xe8, 0xbc, 0x65, 0x6c, 0x1b, 0x9d, 0x1a,
2037         0x16, 0x8f, 0xe8, 0x16, 0x54, 0xc6, 0xc4, 0x75, 0x98, 0x43, 0xc3, 0xd6, 0xca, 0x76, 0xb1, 0x63,
2038         0xf6, 0xda, 0xdd, 0xd7, 0xf9, 0xdd, 0x7b, 0x02, 0x33, 0xc7, 0x09, 0xd6, 0xc2, 0x50, 0x52, 0x36,
2039         0x84, 0x60, 0xd5, 0x23, 0x2e, 0x95, 0xa2, 0x55, 0x2c, 0x9f, 0xd1, 0x4d, 0x28, 0x0f, 0x39, 0x9b,
2040         0xba, 0xde, 0x89, 0xa2, 0xfb, 0x12, 0x82, 0x63, 0xa8, 0xf5, 0x02, 0x4a, 0xca, 0x84, 0x2e, 0x43,
2041         0xf5, 0xa7, 0x29, 0x61, 0xce, 0xd8, 0xa1, 0x81, 0xce, 0x36, 0x35, 0xa0, 0x2e, 0xac, 0x0d, 0x29,
2042         0x63, 0xb1, 0x76, 0x6b, 0xa9, 0x36, 0x65, 0x0c, 0x2b, 0x98, 0x65, 0xc3, 0xaa, 0x78, 0x45, 0xd7,
2043         0xa1, 0x19, 0x39, 0x2e, 0x0d, 0x23, 0xe2, 0xfa, 0xb6, 0xeb, 0x0c, 0x03, 0x1e, 0x4a, 0xf1, 0x22,
2044         0x6e, 0x24, 0xf6, 0x47, 0xd2, 0x8c, 0x36, 0x60, 0xed, 0x98, 0xb0, 0x29, 0x6d, 0xad, 0xc8, 0xe0,
2045         0xea, 0x05, 0x6d, 0x42, 0x89, 0x91, 0x43, 0xca, 0xc2, 0x56, 0x71, 0xbb, 0xd8, 0xa9, 0x62, 0xfd,
2046         0x66, 0xfd, 0x69, 0x40, 0x05, 0xf3, 0x19, 0x26, 0xde, 0x84, 0xa2, 0x1d, 0x68, 0x86, 0x11, 0x09,
2047         0x22, 0xfb, 0x88, 0xce, 0xed, 0x21, 0xe3, 0x21, 0x1d, 0xa9, 0x25, 0x0c, 0x0a, 0xb8, 0x2e, 0x3d,
2048         0x0f, 0xe8, 0x7c, 0x5f, 0xda, 0xd1, 0x35, 0xa8, 0xa7, 0x58, 0xee, 0x53, 0x4f, 0xc5, 0x1b, 0x14,
2049         0x70, 0x2d, 0x46, 0x3e, 0xf1, 0xa9, 0x87, 0x2c, 0xa8, 0x51, 0x6f, 0x94, 0xa2, 0x8a, 0x12, 0x65,
2050         0x60, 0xa0, 0xde, 0x28, 0xc6, 0x5c, 0x83, 0x7a, 0x8c, 0xd1, 0x51, 0x57, 0x35, 0xaa, 0xa6, 0x50,
2051         0x2a, 0x66, 0xdf, 0x84, 0x6a, 0x12, 0xb3, 0x5f, 0x85, 0xb2, 0x26, 0x59, 0x3f, 0x40, 0x09, 0xf3,
2052         0xd9, 0x73, 0x1a, 0xa1, 0x4b, 0x50, 0x09, 0xf8, 0x4c, 0x18, 0x45, 0x7d, 0x8a, 0x9d, 0x1a, 0x2e,
2053         0x07, 0x7c, 0xf6, 0x80, 0xce, 0x43, 0x74, 0x1b, 0x40, 0xb8, 0x02, 0xb1, 0xd2, 0xb8, 0xfe, 0x97,
2054         0x97, 0xd5, 0x3f, 0x2e, 0x07, 0xae, 0x06, 0xfa, 0x29, 0xb4, 0x7e, 0x5b, 0x01, 0x53, 0xef, 0xb9,
2055         0xac, 0xd4, 0x15, 0x30, 0x65, 0x3f, 0xcd, 0xed, 0x4c, 0x03, 0x81, 0x32, 0x3d, 0x16, 0x6d, 0x74,
2056         0x0b, 0x36, 0x55, 0xaa, 0xc9, 0xde, 0xc7, 0x4b, 0x8b, 0xcb, 0xb4, 0x21, 0xfd, 0xcf, 0x62, 0xb7,
2057         0x2e, 0x6b, 0x0f, 0x36, 0x16, 0x79, 0x99, 0xb2, 0x15, 0x30, 0xca, 0xb3, 0x64, 0xf9, 0x7a, 0xb0,
2058         0x21, 0x2a, 0xf1, 0x5a, 0xa4, 0xb8, 0x88, 0x88, 0x7a, 0xa3, 0xc5, 0x38, 0x5d, 0x40, 0x79, 0x8e,
2059         0x8c, 0xb2, 0xa6, 0x19, 0xcd, 0x2c, 0x43, 0xc4, 0xe8, 0x9f, 0x83, 0xc6, 0x42, 0x5e, 0xfd, 0x06,
2060         0xac, 0xe7, 0x24, 0xac, 0x57, 0x50, 0x3f, 0x88, 0x9b, 0x51, 0x95, 0xe9, 0x66, 0x5c, 0x85, 0x37,
2061         0x34, 0xaf, 0x5a, 0xeb, 0xc1, 0x42, 0x07, 0x7f, 0xac, 0xd6, 0xf3, 0x1a, 0x67, 0x45, 0x72, 0x44,
2062         0xde, 0x0b, 0x0c, 0xeb, 0x6f, 0x03, 0xe0, 0x85, 0xe8, 0x73, 0x15, 0xb6, 0x0b, 0xaa, 0x4c, 0xb6,
2063         0xec, 0xfd, 0xc5, 0x4e, 0x56, 0x3d, 0x2e, 0xe1, 0xba, 0x18, 0x49, 0xdf, 0x2b, 0x7c, 0xae, 0x9b,
2064         0xeb, 0x29, 0x5a, 0x16, 0x7b, 0x07, 0x44, 0x71, 0xf2, 0xca, 0x71, 0x4f, 0x8b, 0x2e, 0xce, 0xea,
2065         0xea, 0xbe, 0xce, 0xa8, 0x66, 0xfb, 0x3a, 0xd1, 0xec, 0xaf, 0x83, 0x99, 0x89, 0x2f, 0xda, 0x3c,
2066         0xa1, 0x59, 0xff, 0x9a, 0x50, 0xc5, 0x7c, 0x76, 0xcf, 0x61, 0x11, 0x0d, 0xd0, 0x6d, 0x58, 0x1b,
2067         0xfe, 0x48, 0x1c, 0x4f, 0x2e, 0xc6, 0xec, 0x5d, 0x7d, 0x43, 0xff, 0x2a, 0x74, 0x77, 0x5f, 0x40,
2068         0x07, 0x05, 0xac, 0x38, 0xe8, 0x5b, 0x00, 0xc7, 0x8b, 0x68, 0xc0, 0x28, 0x39, 0x56, 0xe3, 0xc1,
2069         0xec, 0x75, 0x4e, 0x56, 0xf8, 0x26, 0xc1, 0x0f, 0x0a, 0x38, 0xc3, 0x46, 0xf7, 0xa1, 0x3a, 0xe4,
2070         0xde, 0xc8, 0x89, 0x1c, 0xae, 0x9a, 0xd3, 0xec, 0xbd, 0x7f, 0x4a, 0x32, 0x31, 0x7c, 0x50, 0xc0,
2071         0x29, 0x17, 0x6d, 0xc0, 0x6a, 0xe8, 0x78, 0x47, 0xad, 0xe6, 0xb6, 0xd1, 0xa9, 0x0c, 0x0a, 0x58,
2072         0xbe, 0xa1, 0x0e, 0x34, 0x7c, 0x12, 0x86, 0x36, 0x61, 0xcc, 0x1e, 0x4b, 0x7e, 0xeb, 0x9c, 0x06,
2073         0xac, 0x0b, 0xc7, 0x1e, 0x63, 0xba, 0x22, 0x3b, 0xd0, 0x3c, 0x64, 0x7c, 0x78, 0x94, 0x85, 0x22,
2074         0x0d, 0xad, 0x4b, 0x4f, 0x8a, 0xfd, 0x04, 0x36, 0xf4, 0x74, 0xb0, 0x03, 0x3a, 0xa1, 0xaf, 0x62,
2075         0xfc, 0xaa, 0xde, 0xeb, 0x73, 0x6a, 0x56, 0x60, 0xe1, 0xd3, 0x94, 0x0f, 0x41, 0x18, 0xed, 0x90,
2076         0xb8, 0x3e, 0xa3, 0x31, 0xbe, 0xbe, 0x6d, 0x74, 0x8c, 0x41, 0x01, 0x37, 0x02, 0x3e, 0x7b, 0x2e,
2077         0x3d, 0x1a, 0xfd, 0x39, 0xb4, 0x32, 0x63, 0x21, 0x1f, 0x44, 0x9c, 0xad, 0xea, 0xa0, 0x80, 0x2f,
2078         0xa4, 0x53, 0x22, 0x1b, 0x68, 0x1f, 0xb6, 0xd4, 0xc7, 0x24, 0x73, 0x26, 0x73, 0xfc, 0x92, 0x4e,
2079         0xb2, 0xad, 0x60, 0xc9, 0xf1, 0xcc, 0x8a, 0x3c, 0x83, 0xf3, 0x5a, 0x44, 0x8e, 0xb9, 0x98, 0x5a,
2080         0x96, 0xfb, 0x73, 0xe5, 0x84, 0x0f, 0x99, 0x40, 0x8b, 0x02, 0x0c, 0xd3, 0x57, 0x2d, 0xf9, 0x12,
2081         0x36, 0xd3, 0x83, 0x98, 0x53, 0xad, 0x48, 0x55, 0x6b, 0x99, 0x6a, 0x7e, 0x0c, 0x88, 0x61, 0x17,
2082         0xe5, 0x2c, 0x5a, 0xbb, 0x0b, 0x48, 0x9d, 0x8d, 0xdc, 0x42, 0xab, 0xf1, 0x39, 0x95, 0xbe, 0xec,
2083         0xf2, 0x1e, 0x27, 0xf8, 0x6c, 0x1e, 0x0d, 0x99, 0xc7, 0xbb, 0xcb, 0xf2, 0x48, 0x67, 0x42, 0xaa,
2084         0x97, 0x89, 0xff, 0x15, 0xbc, 0x23, 0x3f, 0xb3, 0xb6, 0x2f, 0x8a, 0xcd, 0x67, 0x36, 0x1f, 0x8f,
2085         0x43, 0x1a, 0xc5, 0xc2, 0xb0, 0x6d, 0x74, 0xd6, 0x06, 0x05, 0x7c, 0x51, 0x82, 0x9e, 0xd2, 0x00,
2086         0xf3, 0xd9, 0x13, 0x89, 0xd0, 0xfc, 0x2f, 0xa1, 0x9d, 0xe7, 0x33, 0xc7, 0x75, 0x12, 0xba, 0xa9,
2087         0xe9, 0x9b, 0x19, 0xfa, 0x43, 0x01, 0xd0, 0xec, 0x3e, 0x6c, 0xa5, 0x6c, 0xbd, 0x6d, 0x39, 0x81,
2088         0x9a, 0x16, 0xb8, 0x14, 0x0b, 0xa8, 0xcd, 0xca, 0x6a, 0x7c, 0x06, 0x17, 0xc3, 0x28, 0x70, 0x7c,
2089         0x3d, 0x63, 0xa2, 0x80, 0x78, 0xe1, 0x98, 0x07, 0x2e, 0x0d, 0x5a, 0xeb, 0xfa, 0x10, 0x5c, 0x90,
2090         0x00, 0x59, 0x89, 0x83, 0xd4, 0x2d, 0x98, 0xc4, 0xf7, 0xd9, 0xdc, 0x96, 0x17, 0x81, 0x1c, 0xf3,
2091         0x7c, 0xdc, 0xa9, 0x12, 0xf0, 0x50, 0xf8, 0x33, 0xcc, 0xf6, 0x1d, 0x58, 0x93, 0x83, 0x05, 0x7d,
2092         0x0a, 0x65, 0x95, 0xa9, 0xfa, 0xd6, 0x9a, 0xbd, 0xad, 0x13, 0x27, 0x00, 0x8e, 0xd1, 0xed, 0xaf,
2093         0x01, 0xd2, 0xc1, 0xf2, 0xff, 0x65, 0xfe, 0x32, 0xa0, 0x9a, 0x4c, 0x15, 0x34, 0x80, 0xa6, 0x1f,
2094         0xd0, 0x91, 0x33, 0x24, 0x51, 0xd2, 0x1a, 0x6a, 0x4a, 0x9e, 0xa2, 0xd7, 0x48, 0x68, 0x49, 0x5b,
2095         0x98, 0x51, 0x30, 0x4d, 0x44, 0x56, 0xce, 0x22, 0x02, 0x82, 0xa1, 0xf9, 0x77, 0xa0, 0x36, 0x26,
2096         0x2c, 0x4c, 0x04, 0x8a, 0x67, 0x11, 0x30, 0x25, 0x45, 0xbd, 0xf4, 0x2b, 0x50, 0x52, 0x5c, 0xeb,
2097         0x9f, 0x35, 0xa8, 0x3c, 0x9a, 0x46, 0x44, 0x2e, 0x71, 0x0f, 0x2a, 0xa2, 0x3d, 0x45, 0x3b, 0xe8,
2098         0xa5, 0xbd, 0xb7, 0x4c, 0x34, 0xc6, 0x77, 0x9f, 0xd3, 0x48, 0xdc, 0x1e, 0x07, 0x05, 0x5c, 0x0e,
2099         0xd5, 0x23, 0xfa, 0x1e, 0xd0, 0x88, 0x32, 0x2a, 0x4a, 0x14, 0x70, 0x57, 0xb7, 0x9d, 0x5e, 0xe2,
2100         0x47, 0x27, 0x8a, 0xdd, 0x95, 0xb4, 0x7b, 0x01, 0x77, 0x55, 0x1b, 0x8a, 0x13, 0x35, 0x5a, 0xb0,
2101         0x2d, 0xca, 0xab, 0x51, 0xa7, 0x0b, 0x70, 0x56, 0x79, 0x75, 0x39, 0xcf, 0xcb, 0xeb, 0x0b, 0xfb,
2102         0x01, 0x34, 0xb2, 0xf2, 0x01, 0x9f, 0xc9, 0xd9, 0x6d, 0xf6, 0x76, 0xce, 0xa8, 0x8d, 0xf9, 0x4c,
2103         0x7c, 0x42, 0x46, 0x59, 0x43, 0xfb, 0x17, 0x03, 0xca, 0xba, 0x54, 0xa7, 0x5f, 0xec, 0xae, 0x43,
2104         0x73, 0x71, 0x4e, 0xeb, 0x9b, 0x76, 0x63, 0x61, 0x30, 0x2f, 0xbd, 0xb4, 0x17, 0x4f, 0xb9, 0xb4,
2105         0xaf, 0x66, 0x2e, 0xed, 0xed, 0x5f, 0x0d, 0x68, 0x2e, 0x96, 0xfd, 0xad, 0x66, 0xb8, 0x07, 0x20,
2106         0x32, 0x51, 0xf3, 0x54, 0x6f, 0xd3, 0x19, 0x06, 0x3a, 0xae, 0x0a, 0x96, 0x7c, 0x6c, 0xdf, 0xc8,
2107         0xa6, 0xa8, 0xb7, 0xe9, 0xb4, 0x14, 0xdb, 0x0d, 0x58, 0xcf, 0xed, 0x49, 0x1f, 0xa0, 0xe2, 0xea,
2108         0xdd, 0xb2, 0xfe, 0x30, 0xe0, 0x3c, 0xa6, 0x64, 0xf4, 0x88, 0x8f, 0x9c, 0xf1, 0xfc, 0xbb, 0xc0,
2109         0x89, 0x28, 0x9e, 0x32, 0xfa, 0x56, 0x17, 0x7e, 0x15, 0x6a, 0xc4, 0xf7, 0x93, 0x5b, 0x56, 0x72,
2110         0xbd, 0x36, 0x95, 0x55, 0x4e, 0x4b, 0xf4, 0x01, 0x34, 0x1d, 0x6f, 0x18, 0x50, 0x97, 0x7a, 0x91,
2111         0x4d, 0x5c, 0x3e, 0xf5, 0x22, 0xb9, 0x3f, 0x45, 0xf1, 0xe9, 0x4f, 0x3c, 0x7b, 0xd2, 0xd1, 0x2f,
2112         0xc1, 0x6a, 0x30, 0x65, 0xb4, 0xff, 0x33, 0x6c, 0x0e, 0xb9, 0xbb, 0xa4, 0x86, 0xfd, 0xea, 0x5d,
2113         0x12, 0x91, 0xa7, 0xe2, 0x3f, 0xf7, 0xa9, 0xf1, 0xf2, 0x0b, 0x0d, 0x98, 0x70, 0x46, 0xbc, 0x49,
2114         0x97, 0x07, 0x93, 0xdd, 0x09, 0xf5, 0xe4, 0x5f, 0xf0, 0xae, 0x72, 0x11, 0xdf, 0x09, 0xb3, 0xff,
2115         0xc9, 0xb7, 0xe3, 0xe7, 0xdf, 0x57, 0x5a, 0xf7, 0x15, 0x79, 0x9f, 0xf1, 0xe9, 0xa8, 0xdb, 0x8f,
2116         0x63, 0xbc, 0xe8, 0x1d, 0x96, 0xa4, 0xc2, 0x8d, 0xff, 0x02, 0x00, 0x00, 0xff, 0xff, 0x32, 0x40,
2117         0x30, 0x5e, 0x68, 0x0f, 0x00, 0x00,
2118 }