Example #1
0
  @Test
  public void testBoolean() {
    Buffer buffer = new FixedBuffer(16);
    buffer.put(true);
    buffer.put(false);

    Buffer read = new FixedBuffer(buffer.getBuffer());
    boolean b = read.readBoolean();
    Assert.assertEquals(true, b);

    boolean c = read.readBoolean();
    Assert.assertEquals(false, c);
  }
 protected void updateRecord(T record, PersistenceWindow window) {
   int id = record.getId();
   Buffer buffer = window.getOffsettedBuffer(id);
   if (record.inUse()) {
     buffer.put(Record.IN_USE.byteValue());
     writeRecord(record, buffer);
   } else {
     buffer.put(Record.NOT_IN_USE.byteValue());
     if (!isInRecoveryMode()) {
       freeId(id);
     }
   }
 }
Example #3
0
 @Test
 public void testGetBuffer() throws Exception {
   Buffer buffer = new FixedBuffer(4);
   buffer.put(1);
   Assert.assertEquals(buffer.getOffset(), 4);
   Assert.assertEquals(buffer.getBuffer().length, 4);
 }
Example #4
0
  private void checkUnsignedByte(int value) {
    Buffer buffer = new FixedBuffer(1024);
    buffer.put((byte) value);
    byte[] buffer1 = buffer.getBuffer();

    Buffer reader = new FixedBuffer(buffer1);
    int i = reader.readUnsignedByte();
    Assert.assertEquals(value, i);
  }
Example #5
0
 private void setRecord(long id, long value) {
   PersistenceWindow window = acquireWindow(id, OperationType.WRITE);
   try {
     Buffer buffer = window.getOffsettedBuffer(id);
     buffer.put(Record.IN_USE.byteValue()).putLong(value);
     registerIdFromUpdateRecord(id);
   } finally {
     releaseWindow(window);
   }
 }
Example #6
0
  @Test
  public void testSliceGetBuffer() throws Exception {
    Buffer buffer = new FixedBuffer(5);
    buffer.put(1);
    Assert.assertEquals(buffer.getOffset(), 4);
    Assert.assertEquals(buffer.getBuffer().length, 4);

    byte[] buffer1 = buffer.getBuffer();
    byte[] buffer2 = buffer.getBuffer();
    Assert.assertTrue(buffer1 != buffer2);
  }
Example #7
0
  private void updateRecord(PropertyRecord record, PersistenceWindow window) {
    long id = record.getId();
    registerIdFromUpdateRecord(id);
    Buffer buffer = window.getOffsettedBuffer(id);
    if (record.inUse()) {
      // Set up the record header
      short prevModifier =
          record.getPrevProp() == Record.NO_NEXT_RELATIONSHIP.intValue()
              ? 0
              : (short) ((record.getPrevProp() & 0xF00000000L) >> 28);
      short nextModifier =
          record.getNextProp() == Record.NO_NEXT_RELATIONSHIP.intValue()
              ? 0
              : (short) ((record.getNextProp() & 0xF00000000L) >> 32);
      byte modifiers = (byte) (prevModifier | nextModifier);
      /*
       * [pppp,nnnn] previous, next high bits
       */
      buffer.put(modifiers);
      buffer.putInt((int) record.getPrevProp()).putInt((int) record.getNextProp());

      // Then go through the blocks
      int longsAppended = 0; // For marking the end of blocks
      for (PropertyBlock block : record.getPropertyBlocks()) {
        long[] propBlockValues = block.getValueBlocks();
        for (long propBlockValue : propBlockValues) {
          buffer.putLong(propBlockValue);
        }

        longsAppended += propBlockValues.length;
        /*
         * For each block we need to update its dynamic record chain if
         * it is just created. Deleted dynamic records are in the property
         * record and dynamic records are never modified. Also, they are
         * assigned as a whole, so just checking the first should be enough.
         */
        if (!block.isLight() && block.getValueRecords().get(0).isCreated()) {
          updateDynamicRecords(block.getValueRecords());
        }
      }
      if (longsAppended < PropertyType.getPayloadSizeLongs()) {
        buffer.putLong(0);
      }
    } else {
      if (!isInRecoveryMode()) {
        freeId(id);
      }
      // skip over the record header, nothing useful there
      buffer.setOffset(buffer.getOffset() + 9);
      buffer.putLong(0);
    }
    updateDynamicRecords(record.getDeletedRecords());
  }
Example #8
0
  @Test
  public void readPadStringAndRightTrim() {
    String testString = StringUtils.repeat('a', 10);
    Buffer writeBuffer = new FixedBuffer(32);
    writeBuffer.putPadString(testString, 20);
    writeBuffer.put(255);

    Buffer readBuffer = new FixedBuffer(writeBuffer.getBuffer());
    String readPadString = readBuffer.readPadStringAndRightTrim(20);
    Assert.assertEquals(testString, readPadString);
    int readInt = readBuffer.readInt();
    Assert.assertEquals(255, readInt);
  }
Example #9
0
  @Test
  public void readPadBytes() {
    byte[] bytes = new byte[10];
    random.nextBytes(bytes);
    Buffer writeBuffer = new FixedBuffer(32);
    writeBuffer.putPadBytes(bytes, 20);
    writeBuffer.put(255);

    Buffer readBuffer = new FixedBuffer(writeBuffer.getBuffer());
    byte[] readPadBytes = readBuffer.readPadBytes(20);
    Assert.assertArrayEquals(bytes, Arrays.copyOf(readPadBytes, 10));
    int readInt = readBuffer.readInt();
    Assert.assertEquals(255, readInt);
  }
  protected ColumnFamily getColumnFamily() throws IOException {
    ColumnFamily previous = buffer.get(currentKey);
    // If the CF already exist in memory, we'll just continue adding to it
    if (previous == null) {
      previous = createColumnFamily();
      buffer.put(currentKey, previous);

      // Since this new CF will be written by the next sync(), count its header. And a CF header
      // on disk is:
      //   - the row key: 2 bytes size + key size bytes
      //   - the row level deletion infos: 4 + 8 bytes
      currentSize += 14 + currentKey.getKey().remaining();
    }
    return previous;
  }
Example #11
0
  public void test() throws Exception {
    Consumer consumer = new Consumer(buffer);
    Thread thread = new Thread(consumer);
    thread.start();

    for (int i = 0; i < 1000; i++) {
      buffer.put(new Integer(i));
    }

    thread.join();

    for (int i = 0; i < consumer.taken.size(); i++) {
      Integer integer = (Integer) consumer.taken.get(i);
      assertEquals(i, integer.intValue());
    }
  }
 protected ColumnFamily getColumnFamily() {
   ColumnFamily previous = buffer.get(currentKey);
   // If the CF already exist in memory, we'll just continue adding to it
   if (previous == null) {
     previous = TreeMapBackedSortedColumns.factory.create(metadata);
     buffer.put(currentKey, previous);
   } else {
     // We will reuse a CF that we have counted already. But because it will be easier to add the
     // full size
     // of the CF in the next writeRow call than to find out the delta, we just remove the size
     // until that next call
     currentSize -=
         currentKey.key.remaining()
             + ColumnFamily.serializer.serializedSize(previous, MessagingService.current_version)
                 * 1.2;
   }
   return previous;
 }
Example #13
0
  private void testPutPrefixedBytes(String test, int expected) {
    Buffer buffer = new FixedBuffer(1024);
    if (test != null) {
      buffer.putPrefixedBytes(test.getBytes(UTF8_CHARSET));
    } else {
      buffer.putPrefixedString(null);
    }

    buffer.put(expected);
    byte[] buffer1 = buffer.getBuffer();

    Buffer actual = new FixedBuffer(buffer1);
    String s = actual.readPrefixedString();
    Assert.assertEquals(test, s);

    int i = actual.readInt();
    Assert.assertEquals(expected, i);
  }
Example #14
0
 public void prep(Buffer buf) {
   Colors p = buf.get(colors);
   if (p != null) buf.put(colors, p.combine(this));
   else buf.put(colors, this);
 }
Example #15
0
 public void prep(Buffer buf) {
   buf.put(slot, this);
 }
Example #16
0
 public void prep(Buffer buf) {
   buf.put(depthoffset, this);
 }
Example #17
0
 public void prep(Buffer buf) {
   buf.put(adhocg, this);
 }
Example #18
0
 public void prep(Buffer buf) {
   buf.put(fog, this);
 }
Example #19
0
 public void prep(Buffer buf) {
   buf.put(pointsize, this);
 }
Example #20
0
 public void prep(Buffer buf) {
   buf.put(color, this);
 }
Example #21
0
 public void prep(Buffer buf) {
   buf.put(proj2d, this);
 }
Example #22
0
 public void prep(Buffer buf) {
   buf.put(coverage, this);
 }
Example #23
0
 public void run() {
   char chars[] = line.toCharArray();
   for (char c : chars) {
     buffer.put(c);
   }
 }