View Javadoc

1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one
3    * or more contributor license agreements.  See the NOTICE file
4    * distributed with this work for additional information
5    * regarding copyright ownership.  The ASF licenses this file
6    * to you under the Apache License, Version 2.0 (the
7    * "License"); you may not use this file except in compliance
8    * with the License.  You may obtain a copy of the License at
9    *
10   *     http://www.apache.org/licenses/LICENSE-2.0
11   *
12   * Unless required by applicable law or agreed to in writing, software
13   * distributed under the License is distributed on an "AS IS" BASIS,
14   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15   * See the License for the specific language governing permissions and
16   * limitations under the License.
17   */
18  
19  package org.apache.hadoop.hbase.codec.prefixtree;
20  
21  import java.io.IOException;
22  import java.io.InputStream;
23  import java.io.OutputStream;
24  import java.nio.ByteBuffer;
25  
26  import org.apache.hadoop.classification.InterfaceAudience;
27  import org.apache.hadoop.hbase.codec.prefixtree.encode.other.LongEncoder;
28  import org.apache.hadoop.hbase.util.Bytes;
29  import org.apache.hadoop.hbase.util.vint.UVIntTool;
30  import org.apache.hadoop.hbase.util.vint.UVLongTool;
31  
32  /**
33   * Information about the block.  Stored at the beginning of the byte[].  Contains things
34   * like minimum timestamp and width of FInts in the row tree.
35   *
36   * Most fields stored in VInts that get decoded on the first access of each new block.
37   */
38  @InterfaceAudience.Private
39  public class PrefixTreeBlockMeta {
40  
41    /******************* static fields ********************/
42  
43    public static final int VERSION = 0;
44  
45    public static final int MAX_FAMILY_LENGTH = Byte.MAX_VALUE;// hard-coded in KeyValue
46  
47    public static final int
48  	  NUM_LONGS = 2,
49      NUM_INTS = 22,
50      NUM_SHORTS = 0,//keyValueTypeWidth not persisted
51      NUM_SINGLE_BYTES = 2,
52      MAX_BYTES = Bytes.SIZEOF_LONG * NUM_LONGS
53          + Bytes.SIZEOF_SHORT * NUM_SHORTS
54          + Bytes.SIZEOF_INT * NUM_INTS
55          + NUM_SINGLE_BYTES;
56  
57  
58    /**************** transient fields *********************/
59  
60    protected int arrayOffset;
61    protected int bufferOffset;
62  
63  
64    /**************** persisted fields **********************/
65  
66    // PrefixTree version to allow future format modifications
67    protected int version;
68    protected int numMetaBytes;
69    protected int numKeyValueBytes;
70    protected boolean includesMvccVersion;//probably don't need this explicitly, but only 1 byte
71  
72    // split the byte[] into 6 sections for the different data types
73    protected int numRowBytes;
74    protected int numFamilyBytes;
75    protected int numQualifierBytes;
76    protected int numTimestampBytes;
77    protected int numMvccVersionBytes;
78    protected int numValueBytes;
79  
80    // number of bytes in each section of fixed width FInts
81    protected int nextNodeOffsetWidth;
82    protected int familyOffsetWidth;
83    protected int qualifierOffsetWidth;
84    protected int timestampIndexWidth;
85    protected int mvccVersionIndexWidth;
86    protected int valueOffsetWidth;
87    protected int valueLengthWidth;
88  
89    // used to pre-allocate structures for reading
90    protected int rowTreeDepth;
91    protected int maxRowLength;
92    protected int maxQualifierLength;
93  
94    // the timestamp from which the deltas are calculated
95    protected long minTimestamp;
96    protected int timestampDeltaWidth;
97    protected long minMvccVersion;
98    protected int mvccVersionDeltaWidth;
99  
100   protected boolean allSameType;
101   protected byte allTypes;
102 
103   protected int numUniqueRows;
104   protected int numUniqueFamilies;
105   protected int numUniqueQualifiers;
106 
107 
108   /***************** constructors ********************/
109 
110   public PrefixTreeBlockMeta() {
111   }
112 
113   public PrefixTreeBlockMeta(InputStream is) throws IOException{
114     this.version = VERSION;
115     this.arrayOffset = 0;
116     this.bufferOffset = 0;
117     readVariableBytesFromInputStream(is);
118   }
119 
120   /**
121    * @param buffer positioned at start of PtBlockMeta
122    */
123   public PrefixTreeBlockMeta(ByteBuffer buffer) {
124     initOnBlock(buffer);
125   }
126 
127   public void initOnBlock(ByteBuffer buffer) {
128     arrayOffset = buffer.arrayOffset();
129     bufferOffset = buffer.position();
130     readVariableBytesFromArray(buffer.array(), arrayOffset + bufferOffset);
131   }
132 
133 
134 	/**************** operate on each field **********************/
135 
136   public int calculateNumMetaBytes(){
137     int numBytes = 0;
138     numBytes += UVIntTool.numBytes(version);
139     numBytes += UVLongTool.numBytes(numMetaBytes);
140     numBytes += UVIntTool.numBytes(numKeyValueBytes);
141     ++numBytes;//os.write(getIncludesMvccVersion());
142 
143     numBytes += UVIntTool.numBytes(numRowBytes);
144     numBytes += UVIntTool.numBytes(numFamilyBytes);
145     numBytes += UVIntTool.numBytes(numQualifierBytes);
146     numBytes += UVIntTool.numBytes(numTimestampBytes);
147     numBytes += UVIntTool.numBytes(numMvccVersionBytes);
148     numBytes += UVIntTool.numBytes(numValueBytes);
149 
150     numBytes += UVIntTool.numBytes(nextNodeOffsetWidth);
151     numBytes += UVIntTool.numBytes(familyOffsetWidth);
152     numBytes += UVIntTool.numBytes(qualifierOffsetWidth);
153     numBytes += UVIntTool.numBytes(timestampIndexWidth);
154     numBytes += UVIntTool.numBytes(mvccVersionIndexWidth);
155     numBytes += UVIntTool.numBytes(valueOffsetWidth);
156     numBytes += UVIntTool.numBytes(valueLengthWidth);
157 
158     numBytes += UVIntTool.numBytes(rowTreeDepth);
159     numBytes += UVIntTool.numBytes(maxRowLength);
160     numBytes += UVIntTool.numBytes(maxQualifierLength);
161 
162     numBytes += UVLongTool.numBytes(minTimestamp);
163     numBytes += UVIntTool.numBytes(timestampDeltaWidth);
164     numBytes += UVLongTool.numBytes(minMvccVersion);
165     numBytes += UVIntTool.numBytes(mvccVersionDeltaWidth);
166     ++numBytes;//os.write(getAllSameTypeByte());
167     ++numBytes;//os.write(allTypes);
168 
169     numBytes += UVIntTool.numBytes(numUniqueRows);
170     numBytes += UVIntTool.numBytes(numUniqueFamilies);
171     numBytes += UVIntTool.numBytes(numUniqueQualifiers);
172     return numBytes;
173   }
174 
175   public void writeVariableBytesToOutputStream(OutputStream os) throws IOException{
176       UVIntTool.writeBytes(version, os);
177       UVIntTool.writeBytes(numMetaBytes, os);
178       UVIntTool.writeBytes(numKeyValueBytes, os);
179       os.write(getIncludesMvccVersionByte());
180 
181       UVIntTool.writeBytes(numRowBytes, os);
182       UVIntTool.writeBytes(numFamilyBytes, os);
183       UVIntTool.writeBytes(numQualifierBytes, os);
184       UVIntTool.writeBytes(numTimestampBytes, os);
185       UVIntTool.writeBytes(numMvccVersionBytes, os);
186       UVIntTool.writeBytes(numValueBytes, os);
187 
188       UVIntTool.writeBytes(nextNodeOffsetWidth, os);
189       UVIntTool.writeBytes(familyOffsetWidth, os);
190       UVIntTool.writeBytes(qualifierOffsetWidth, os);
191       UVIntTool.writeBytes(timestampIndexWidth, os);
192       UVIntTool.writeBytes(mvccVersionIndexWidth, os);
193       UVIntTool.writeBytes(valueOffsetWidth, os);
194       UVIntTool.writeBytes(valueLengthWidth, os);
195 
196       UVIntTool.writeBytes(rowTreeDepth, os);
197       UVIntTool.writeBytes(maxRowLength, os);
198       UVIntTool.writeBytes(maxQualifierLength, os);
199 
200       UVLongTool.writeBytes(minTimestamp, os);
201       UVIntTool.writeBytes(timestampDeltaWidth, os);
202       UVLongTool.writeBytes(minMvccVersion, os);
203       UVIntTool.writeBytes(mvccVersionDeltaWidth, os);
204       os.write(getAllSameTypeByte());
205       os.write(allTypes);
206 
207       UVIntTool.writeBytes(numUniqueRows, os);
208       UVIntTool.writeBytes(numUniqueFamilies, os);
209       UVIntTool.writeBytes(numUniqueQualifiers, os);
210   }
211 
212   public void readVariableBytesFromInputStream(InputStream is) throws IOException{
213       version = UVIntTool.getInt(is);
214       numMetaBytes = UVIntTool.getInt(is);
215       numKeyValueBytes = UVIntTool.getInt(is);
216       setIncludesMvccVersion((byte) is.read());
217 
218       numRowBytes = UVIntTool.getInt(is);
219       numFamilyBytes = UVIntTool.getInt(is);
220       numQualifierBytes = UVIntTool.getInt(is);
221       numTimestampBytes = UVIntTool.getInt(is);
222       numMvccVersionBytes = UVIntTool.getInt(is);
223       numValueBytes = UVIntTool.getInt(is);
224 
225       nextNodeOffsetWidth = UVIntTool.getInt(is);
226       familyOffsetWidth = UVIntTool.getInt(is);
227       qualifierOffsetWidth = UVIntTool.getInt(is);
228       timestampIndexWidth = UVIntTool.getInt(is);
229       mvccVersionIndexWidth = UVIntTool.getInt(is);
230       valueOffsetWidth = UVIntTool.getInt(is);
231       valueLengthWidth = UVIntTool.getInt(is);
232 
233       rowTreeDepth = UVIntTool.getInt(is);
234       maxRowLength = UVIntTool.getInt(is);
235       maxQualifierLength = UVIntTool.getInt(is);
236 
237       minTimestamp = UVLongTool.getLong(is);
238       timestampDeltaWidth = UVIntTool.getInt(is);
239       minMvccVersion = UVLongTool.getLong(is);
240       mvccVersionDeltaWidth = UVIntTool.getInt(is);
241 
242       setAllSameType((byte) is.read());
243       allTypes = (byte) is.read();
244 
245       numUniqueRows = UVIntTool.getInt(is);
246       numUniqueFamilies = UVIntTool.getInt(is);
247       numUniqueQualifiers = UVIntTool.getInt(is);
248   }
249 
250   public void readVariableBytesFromArray(byte[] bytes, int offset) {
251     int position = offset;
252 
253     version = UVIntTool.getInt(bytes, position);
254     position += UVIntTool.numBytes(version);
255     numMetaBytes = UVIntTool.getInt(bytes, position);
256     position += UVIntTool.numBytes(numMetaBytes);
257     numKeyValueBytes = UVIntTool.getInt(bytes, position);
258     position += UVIntTool.numBytes(numKeyValueBytes);
259     setIncludesMvccVersion(bytes[position]);
260     ++position;
261 
262     numRowBytes = UVIntTool.getInt(bytes, position);
263     position += UVIntTool.numBytes(numRowBytes);
264     numFamilyBytes = UVIntTool.getInt(bytes, position);
265     position += UVIntTool.numBytes(numFamilyBytes);
266     numQualifierBytes = UVIntTool.getInt(bytes, position);
267     position += UVIntTool.numBytes(numQualifierBytes);
268     numTimestampBytes = UVIntTool.getInt(bytes, position);
269     position += UVIntTool.numBytes(numTimestampBytes);
270     numMvccVersionBytes = UVIntTool.getInt(bytes, position);
271     position += UVIntTool.numBytes(numMvccVersionBytes);
272     numValueBytes = UVIntTool.getInt(bytes, position);
273     position += UVIntTool.numBytes(numValueBytes);
274 
275     nextNodeOffsetWidth = UVIntTool.getInt(bytes, position);
276     position += UVIntTool.numBytes(nextNodeOffsetWidth);
277     familyOffsetWidth = UVIntTool.getInt(bytes, position);
278     position += UVIntTool.numBytes(familyOffsetWidth);
279     qualifierOffsetWidth = UVIntTool.getInt(bytes, position);
280     position += UVIntTool.numBytes(qualifierOffsetWidth);
281     timestampIndexWidth = UVIntTool.getInt(bytes, position);
282     position += UVIntTool.numBytes(timestampIndexWidth);
283     mvccVersionIndexWidth = UVIntTool.getInt(bytes, position);
284     position += UVIntTool.numBytes(mvccVersionIndexWidth);
285     valueOffsetWidth = UVIntTool.getInt(bytes, position);
286     position += UVIntTool.numBytes(valueOffsetWidth);
287     valueLengthWidth = UVIntTool.getInt(bytes, position);
288     position += UVIntTool.numBytes(valueLengthWidth);
289 
290     rowTreeDepth = UVIntTool.getInt(bytes, position);
291     position += UVIntTool.numBytes(rowTreeDepth);
292     maxRowLength = UVIntTool.getInt(bytes, position);
293     position += UVIntTool.numBytes(maxRowLength);
294     maxQualifierLength = UVIntTool.getInt(bytes, position);
295     position += UVIntTool.numBytes(maxQualifierLength);
296 
297     minTimestamp = UVLongTool.getLong(bytes, position);
298     position += UVLongTool.numBytes(minTimestamp);
299     timestampDeltaWidth = UVIntTool.getInt(bytes, position);
300     position += UVIntTool.numBytes(timestampDeltaWidth);
301     minMvccVersion = UVLongTool.getLong(bytes, position);
302     position += UVLongTool.numBytes(minMvccVersion);
303     mvccVersionDeltaWidth = UVIntTool.getInt(bytes, position);
304     position += UVIntTool.numBytes(mvccVersionDeltaWidth);
305 
306     setAllSameType(bytes[position]);
307     ++position;
308     allTypes = bytes[position];
309     ++position;
310 
311     numUniqueRows = UVIntTool.getInt(bytes, position);
312     position += UVIntTool.numBytes(numUniqueRows);
313     numUniqueFamilies = UVIntTool.getInt(bytes, position);
314     position += UVIntTool.numBytes(numUniqueFamilies);
315     numUniqueQualifiers = UVIntTool.getInt(bytes, position);
316     position += UVIntTool.numBytes(numUniqueQualifiers);
317   }
318 
319 	//TODO method that can read directly from ByteBuffer instead of InputStream
320 
321 
322   /*************** methods *************************/
323 
324   public int getKeyValueTypeWidth() {
325     return allSameType ? 0 : 1;
326   }
327 
328   public byte getIncludesMvccVersionByte() {
329     return includesMvccVersion ? (byte) 1 : (byte) 0;
330   }
331 
332   public void setIncludesMvccVersion(byte includesMvccVersionByte) {
333     includesMvccVersion = includesMvccVersionByte != 0;
334   }
335 
336   public byte getAllSameTypeByte() {
337     return allSameType ? (byte) 1 : (byte) 0;
338   }
339 
340   public void setAllSameType(byte allSameTypeByte) {
341     allSameType = allSameTypeByte != 0;
342   }
343 
344   public boolean isAllSameTimestamp() {
345     return timestampIndexWidth == 0;
346   }
347 
348   public boolean isAllSameMvccVersion() {
349     return mvccVersionIndexWidth == 0;
350   }
351 
352   public void setTimestampFields(LongEncoder encoder){
353     this.minTimestamp = encoder.getMin();
354     this.timestampIndexWidth = encoder.getBytesPerIndex();
355     this.timestampDeltaWidth = encoder.getBytesPerDelta();
356     this.numTimestampBytes = encoder.getTotalCompressedBytes();
357   }
358 
359   public void setMvccVersionFields(LongEncoder encoder){
360     this.minMvccVersion = encoder.getMin();
361     this.mvccVersionIndexWidth = encoder.getBytesPerIndex();
362     this.mvccVersionDeltaWidth = encoder.getBytesPerDelta();
363     this.numMvccVersionBytes = encoder.getTotalCompressedBytes();
364   }
365 
366 
367   /*************** Object methods *************************/
368 
369   /**
370    * Generated by Eclipse
371    */
372   @Override
373   public boolean equals(Object obj) {
374     if (this == obj)
375       return true;
376     if (obj == null)
377       return false;
378     if (getClass() != obj.getClass())
379       return false;
380     PrefixTreeBlockMeta other = (PrefixTreeBlockMeta) obj;
381     if (allSameType != other.allSameType)
382       return false;
383     if (allTypes != other.allTypes)
384       return false;
385     if (arrayOffset != other.arrayOffset)
386       return false;
387     if (bufferOffset != other.bufferOffset)
388       return false;
389     if (valueLengthWidth != other.valueLengthWidth)
390       return false;
391     if (valueOffsetWidth != other.valueOffsetWidth)
392       return false;
393     if (familyOffsetWidth != other.familyOffsetWidth)
394       return false;
395     if (includesMvccVersion != other.includesMvccVersion)
396       return false;
397     if (maxQualifierLength != other.maxQualifierLength)
398       return false;
399     if (maxRowLength != other.maxRowLength)
400       return false;
401     if (mvccVersionDeltaWidth != other.mvccVersionDeltaWidth)
402       return false;
403     if (mvccVersionIndexWidth != other.mvccVersionIndexWidth)
404       return false;
405     if (minMvccVersion != other.minMvccVersion)
406       return false;
407     if (minTimestamp != other.minTimestamp)
408       return false;
409     if (nextNodeOffsetWidth != other.nextNodeOffsetWidth)
410       return false;
411     if (numValueBytes != other.numValueBytes)
412       return false;
413     if (numFamilyBytes != other.numFamilyBytes)
414       return false;
415     if (numMvccVersionBytes != other.numMvccVersionBytes)
416       return false;
417     if (numMetaBytes != other.numMetaBytes)
418       return false;
419     if (numQualifierBytes != other.numQualifierBytes)
420       return false;
421     if (numRowBytes != other.numRowBytes)
422       return false;
423     if (numTimestampBytes != other.numTimestampBytes)
424       return false;
425     if (numUniqueFamilies != other.numUniqueFamilies)
426       return false;
427     if (numUniqueQualifiers != other.numUniqueQualifiers)
428       return false;
429     if (numUniqueRows != other.numUniqueRows)
430       return false;
431     if (numKeyValueBytes != other.numKeyValueBytes)
432       return false;
433     if (qualifierOffsetWidth != other.qualifierOffsetWidth)
434       return false;
435     if (rowTreeDepth != other.rowTreeDepth)
436       return false;
437     if (timestampDeltaWidth != other.timestampDeltaWidth)
438       return false;
439     if (timestampIndexWidth != other.timestampIndexWidth)
440       return false;
441     if (version != other.version)
442       return false;
443     return true;
444   }
445 
446   /**
447    * Generated by Eclipse
448    */
449   @Override
450   public int hashCode() {
451     final int prime = 31;
452     int result = 1;
453     result = prime * result + (allSameType ? 1231 : 1237);
454     result = prime * result + allTypes;
455     result = prime * result + arrayOffset;
456     result = prime * result + bufferOffset;
457     result = prime * result + valueLengthWidth;
458     result = prime * result + valueOffsetWidth;
459     result = prime * result + familyOffsetWidth;
460     result = prime * result + (includesMvccVersion ? 1231 : 1237);
461     result = prime * result + maxQualifierLength;
462     result = prime * result + maxRowLength;
463     result = prime * result + mvccVersionDeltaWidth;
464     result = prime * result + mvccVersionIndexWidth;
465     result = prime * result + (int) (minMvccVersion ^ (minMvccVersion >>> 32));
466     result = prime * result + (int) (minTimestamp ^ (minTimestamp >>> 32));
467     result = prime * result + nextNodeOffsetWidth;
468     result = prime * result + numValueBytes;
469     result = prime * result + numFamilyBytes;
470     result = prime * result + numMvccVersionBytes;
471     result = prime * result + numMetaBytes;
472     result = prime * result + numQualifierBytes;
473     result = prime * result + numRowBytes;
474     result = prime * result + numTimestampBytes;
475     result = prime * result + numUniqueFamilies;
476     result = prime * result + numUniqueQualifiers;
477     result = prime * result + numUniqueRows;
478     result = prime * result + numKeyValueBytes;
479     result = prime * result + qualifierOffsetWidth;
480     result = prime * result + rowTreeDepth;
481     result = prime * result + timestampDeltaWidth;
482     result = prime * result + timestampIndexWidth;
483     result = prime * result + version;
484     return result;
485   }
486 
487   /**
488    * Generated by Eclipse
489    */
490   @Override
491   public String toString() {
492     StringBuilder builder = new StringBuilder();
493     builder.append("PtBlockMeta [arrayOffset=");
494     builder.append(arrayOffset);
495     builder.append(", bufferOffset=");
496     builder.append(bufferOffset);
497     builder.append(", version=");
498     builder.append(version);
499     builder.append(", numMetaBytes=");
500     builder.append(numMetaBytes);
501     builder.append(", numKeyValueBytes=");
502     builder.append(numKeyValueBytes);
503     builder.append(", includesMvccVersion=");
504     builder.append(includesMvccVersion);
505     builder.append(", numRowBytes=");
506     builder.append(numRowBytes);
507     builder.append(", numFamilyBytes=");
508     builder.append(numFamilyBytes);
509     builder.append(", numQualifierBytes=");
510     builder.append(numQualifierBytes);
511     builder.append(", numTimestampBytes=");
512     builder.append(numTimestampBytes);
513     builder.append(", numMvccVersionBytes=");
514     builder.append(numMvccVersionBytes);
515     builder.append(", numValueBytes=");
516     builder.append(numValueBytes);
517     builder.append(", nextNodeOffsetWidth=");
518     builder.append(nextNodeOffsetWidth);
519     builder.append(", familyOffsetWidth=");
520     builder.append(familyOffsetWidth);
521     builder.append(", qualifierOffsetWidth=");
522     builder.append(qualifierOffsetWidth);
523     builder.append(", timestampIndexWidth=");
524     builder.append(timestampIndexWidth);
525     builder.append(", mvccVersionIndexWidth=");
526     builder.append(mvccVersionIndexWidth);
527     builder.append(", valueOffsetWidth=");
528     builder.append(valueOffsetWidth);
529     builder.append(", valueLengthWidth=");
530     builder.append(valueLengthWidth);
531     builder.append(", rowTreeDepth=");
532     builder.append(rowTreeDepth);
533     builder.append(", maxRowLength=");
534     builder.append(maxRowLength);
535     builder.append(", maxQualifierLength=");
536     builder.append(maxQualifierLength);
537     builder.append(", minTimestamp=");
538     builder.append(minTimestamp);
539     builder.append(", timestampDeltaWidth=");
540     builder.append(timestampDeltaWidth);
541     builder.append(", minMvccVersion=");
542     builder.append(minMvccVersion);
543     builder.append(", mvccVersionDeltaWidth=");
544     builder.append(mvccVersionDeltaWidth);
545     builder.append(", allSameType=");
546     builder.append(allSameType);
547     builder.append(", allTypes=");
548     builder.append(allTypes);
549     builder.append(", numUniqueRows=");
550     builder.append(numUniqueRows);
551     builder.append(", numUniqueFamilies=");
552     builder.append(numUniqueFamilies);
553     builder.append(", numUniqueQualifiers=");
554     builder.append(numUniqueQualifiers);
555     builder.append("]");
556     return builder.toString();
557   }
558 
559 
560   /************** absolute getters *******************/
561 
562   public int getAbsoluteMetaOffset() {
563     return arrayOffset + bufferOffset;
564   }
565 
566   public int getAbsoluteRowOffset() {
567     return getAbsoluteMetaOffset() + numMetaBytes;
568   }
569 
570   public int getAbsoluteFamilyOffset() {
571     return getAbsoluteRowOffset() + numRowBytes;
572   }
573 
574   public int getAbsoluteQualifierOffset() {
575     return getAbsoluteFamilyOffset() + numFamilyBytes;
576   }
577 
578   public int getAbsoluteTimestampOffset() {
579     return getAbsoluteQualifierOffset() + numQualifierBytes;
580   }
581 
582   public int getAbsoluteMvccVersionOffset() {
583     return getAbsoluteTimestampOffset() + numTimestampBytes;
584   }
585 
586   public int getAbsoluteValueOffset() {
587     return getAbsoluteMvccVersionOffset() + numMvccVersionBytes;
588   }
589 
590 
591   /*************** get/set ***************************/
592 
593   public int getTimestampDeltaWidth() {
594     return timestampDeltaWidth;
595   }
596 
597   public void setTimestampDeltaWidth(int timestampDeltaWidth) {
598     this.timestampDeltaWidth = timestampDeltaWidth;
599   }
600 
601   public int getValueOffsetWidth() {
602     return valueOffsetWidth;
603   }
604 
605   public void setValueOffsetWidth(int dataOffsetWidth) {
606     this.valueOffsetWidth = dataOffsetWidth;
607   }
608 
609   public int getValueLengthWidth() {
610     return valueLengthWidth;
611   }
612 
613   public void setValueLengthWidth(int dataLengthWidth) {
614     this.valueLengthWidth = dataLengthWidth;
615   }
616 
617   public int getMaxRowLength() {
618     return maxRowLength;
619   }
620 
621   public void setMaxRowLength(int maxRowLength) {
622     this.maxRowLength = maxRowLength;
623   }
624 
625   public long getMinTimestamp() {
626     return minTimestamp;
627   }
628 
629   public void setMinTimestamp(long minTimestamp) {
630     this.minTimestamp = minTimestamp;
631   }
632 
633   public byte getAllTypes() {
634     return allTypes;
635   }
636 
637   public void setAllTypes(byte allTypes) {
638     this.allTypes = allTypes;
639   }
640 
641   public boolean isAllSameType() {
642     return allSameType;
643   }
644 
645   public void setAllSameType(boolean allSameType) {
646     this.allSameType = allSameType;
647   }
648 
649   public int getNextNodeOffsetWidth() {
650     return nextNodeOffsetWidth;
651   }
652 
653   public void setNextNodeOffsetWidth(int nextNodeOffsetWidth) {
654     this.nextNodeOffsetWidth = nextNodeOffsetWidth;
655   }
656 
657   public int getNumRowBytes() {
658     return numRowBytes;
659   }
660 
661   public void setNumRowBytes(int numRowBytes) {
662     this.numRowBytes = numRowBytes;
663   }
664 
665   public int getNumTimestampBytes() {
666     return numTimestampBytes;
667   }
668 
669   public void setNumTimestampBytes(int numTimestampBytes) {
670     this.numTimestampBytes = numTimestampBytes;
671   }
672 
673   public int getNumValueBytes() {
674     return numValueBytes;
675   }
676 
677   public void setNumValueBytes(int numValueBytes) {
678     this.numValueBytes = numValueBytes;
679   }
680 
681   public int getNumMetaBytes() {
682     return numMetaBytes;
683   }
684 
685   public void setNumMetaBytes(int numMetaBytes) {
686     this.numMetaBytes = numMetaBytes;
687   }
688 
689   public int getArrayOffset() {
690     return arrayOffset;
691   }
692 
693   public void setArrayOffset(int arrayOffset) {
694     this.arrayOffset = arrayOffset;
695   }
696 
697   public int getBufferOffset() {
698     return bufferOffset;
699   }
700 
701   public void setBufferOffset(int bufferOffset) {
702     this.bufferOffset = bufferOffset;
703   }
704 
705   public int getNumKeyValueBytes() {
706     return numKeyValueBytes;
707   }
708 
709   public void setNumKeyValueBytes(int numKeyValueBytes) {
710     this.numKeyValueBytes = numKeyValueBytes;
711   }
712 
713   public int getRowTreeDepth() {
714     return rowTreeDepth;
715   }
716 
717   public void setRowTreeDepth(int rowTreeDepth) {
718     this.rowTreeDepth = rowTreeDepth;
719   }
720 
721   public int getNumMvccVersionBytes() {
722     return numMvccVersionBytes;
723   }
724 
725   public void setNumMvccVersionBytes(int numMvccVersionBytes) {
726     this.numMvccVersionBytes = numMvccVersionBytes;
727   }
728 
729   public int getMvccVersionDeltaWidth() {
730     return mvccVersionDeltaWidth;
731   }
732 
733   public void setMvccVersionDeltaWidth(int mvccVersionDeltaWidth) {
734     this.mvccVersionDeltaWidth = mvccVersionDeltaWidth;
735   }
736 
737   public long getMinMvccVersion() {
738     return minMvccVersion;
739   }
740 
741   public void setMinMvccVersion(long minMvccVersion) {
742     this.minMvccVersion = minMvccVersion;
743   }
744 
745   public int getNumFamilyBytes() {
746     return numFamilyBytes;
747   }
748 
749   public void setNumFamilyBytes(int numFamilyBytes) {
750     this.numFamilyBytes = numFamilyBytes;
751   }
752 
753   public int getFamilyOffsetWidth() {
754     return familyOffsetWidth;
755   }
756 
757   public void setFamilyOffsetWidth(int familyOffsetWidth) {
758     this.familyOffsetWidth = familyOffsetWidth;
759   }
760 
761   public int getNumUniqueRows() {
762     return numUniqueRows;
763   }
764 
765   public void setNumUniqueRows(int numUniqueRows) {
766     this.numUniqueRows = numUniqueRows;
767   }
768 
769   public int getNumUniqueFamilies() {
770     return numUniqueFamilies;
771   }
772 
773   public void setNumUniqueFamilies(int numUniqueFamilies) {
774     this.numUniqueFamilies = numUniqueFamilies;
775   }
776 
777   public int getNumUniqueQualifiers() {
778     return numUniqueQualifiers;
779   }
780 
781   public void setNumUniqueQualifiers(int numUniqueQualifiers) {
782     this.numUniqueQualifiers = numUniqueQualifiers;
783   }
784 
785   public int getNumQualifierBytes() {
786     return numQualifierBytes;
787   }
788 
789   public void setNumQualifierBytes(int numQualifierBytes) {
790     this.numQualifierBytes = numQualifierBytes;
791   }
792 
793   public int getQualifierOffsetWidth() {
794     return qualifierOffsetWidth;
795   }
796 
797   public void setQualifierOffsetWidth(int qualifierOffsetWidth) {
798     this.qualifierOffsetWidth = qualifierOffsetWidth;
799   }
800 
801   public int getMaxQualifierLength() {
802     return maxQualifierLength;
803   }
804 
805   public void setMaxQualifierLength(int maxQualifierLength) {
806     this.maxQualifierLength = maxQualifierLength;
807   }
808 
809   public int getTimestampIndexWidth() {
810     return timestampIndexWidth;
811   }
812 
813   public void setTimestampIndexWidth(int timestampIndexWidth) {
814     this.timestampIndexWidth = timestampIndexWidth;
815   }
816 
817   public int getMvccVersionIndexWidth() {
818     return mvccVersionIndexWidth;
819   }
820 
821   public void setMvccVersionIndexWidth(int mvccVersionIndexWidth) {
822     this.mvccVersionIndexWidth = mvccVersionIndexWidth;
823   }
824 
825   public int getVersion() {
826     return version;
827   }
828 
829   public void setVersion(int version) {
830     this.version = version;
831   }
832 
833   public boolean isIncludesMvccVersion() {
834     return includesMvccVersion;
835   }
836 
837   public void setIncludesMvccVersion(boolean includesMvccVersion) {
838     this.includesMvccVersion = includesMvccVersion;
839   }
840 
841 }