Esempio n. 1
0
  @Override
  public void append(Framedata nextframe) throws InvalidFrameException {
    ByteBuffer b = nextframe.getPayloadData();
    if (unmaskedpayload == null) {
      unmaskedpayload = ByteBuffer.allocate(b.remaining());
      b.mark();
      unmaskedpayload.put(b);
      b.reset();
    } else {
      b.mark();
      unmaskedpayload.position(unmaskedpayload.limit());
      unmaskedpayload.limit(unmaskedpayload.capacity());

      if (b.remaining() > unmaskedpayload.remaining()) {
        ByteBuffer tmp = ByteBuffer.allocate(b.remaining() + unmaskedpayload.capacity());
        unmaskedpayload.flip();
        tmp.put(unmaskedpayload);
        tmp.put(b);
        unmaskedpayload = tmp;

      } else {
        unmaskedpayload.put(b);
      }
      unmaskedpayload.rewind();
      b.reset();
    }
    fin = nextframe.isFin();
  }
Esempio n. 2
0
  public void applyToMapping(AbstractTaggedMapping m) {
    readLength = m.getLength();
    forwardStrand = !m.isOnReverse();
    sequence = m.getSequence();

    if (!forwardStrand) {
      // calculate the reversed complement
      if (revComplement.capacity() < readLength) // ensure space is sufficient
      {
        revComplement = ByteBuffer.allocate(readLength);
        revComplement.mark();
      }
      // now revComplement the read into the buffer
      revComplement.reset();
      int startPos = sequence.position();
      for (int pos = startPos + readLength - 1; pos >= startPos; --pos)
        revComplement.put(complementByte.get(sequence.get(pos)));
      revComplement.reset();

      sequence = revComplement;
    }
    // now sequence is what was read by the sequencer

    // Calculate the dinucleotides.  We calculate them starting from the beginning
    // of 'sequence', but the order in which they are inserted into 'values' must
    // match the original base order.
    final byte[] seqArray = sequence.array();
    final int sequenceStart = sequence.position();
    int valuesPtr;
    int valuesIncrement;
    if (forwardStrand) {
      values[0] = NN;
      valuesPtr = 1;
      valuesIncrement = 1;
    } else {
      values[readLength - 1] = NN;
      valuesPtr = readLength - 2;
      valuesIncrement = -1;
    }

    // for each "previous" base, if it's an N insert a value of NN, otherwise the
    // dinucleotide (previous, previous+1)
    for (int previous = 0; previous < readLength - 1; ++previous) {
      if (seqArray[sequenceStart + previous] == 'N') // if previous base is an N
      values[valuesPtr] = NN;
      else
        values[valuesPtr] =
            new String(
                seqArray,
                sequenceStart + previous,
                2); // string length 2 starting from seqArray[previous]
      valuesPtr += valuesIncrement;
    }
  }
Esempio n. 3
0
  /**
   * Read line.
   *
   * @param buf the buf
   * @return the string
   */
  public static String readLine(ByteBuffer buf) {
    boolean completed = false;
    buf.mark();
    while (buf.hasRemaining() && !completed) {
      byte b = buf.get();
      if (b == '\r') {
        if (buf.hasRemaining() && buf.get() == '\n') {
          completed = true;
        }
      }
    }

    if (!completed) {
      return null;
    }

    int limit = buf.position();
    buf.reset();
    int length = limit - buf.position();
    byte[] tmp = new byte[length];
    buf.get(tmp, 0, length);
    try {
      String line = new String(tmp, "US-ASCII");
      if (log.isLoggable(Level.FINEST)) {
        log.finest(line.trim());
      }
      return line;
    } catch (UnsupportedEncodingException e) {;
    }
    return null;
  }
Esempio n. 4
0
  /**
   * Returns the next code point at the current position in the buffer. The buffer's position will
   * be incremented. Any mark set on this buffer will be changed by this method!
   */
  public static int bytesToCodePoint(ByteBuffer bytes) {
    bytes.mark();
    byte b = bytes.get();
    bytes.reset();
    int extraBytesToRead = bytesFromUTF8[(b & 0xFF)];
    if (extraBytesToRead < 0) return -1; // trailing byte!
    int ch = 0;

    switch (extraBytesToRead) {
      case 5:
        ch += (bytes.get() & 0xFF);
        ch <<= 6; /* remember, illegal UTF-8 */
      case 4:
        ch += (bytes.get() & 0xFF);
        ch <<= 6; /* remember, illegal UTF-8 */
      case 3:
        ch += (bytes.get() & 0xFF);
        ch <<= 6;
      case 2:
        ch += (bytes.get() & 0xFF);
        ch <<= 6;
      case 1:
        ch += (bytes.get() & 0xFF);
        ch <<= 6;
      case 0:
        ch += (bytes.get() & 0xFF);
    }
    ch -= offsetsFromUTF8[extraBytesToRead];

    return ch;
  }
Esempio n. 5
0
  protected CoderResult decodeLoop(ByteBuffer in, CharBuffer out) {

    while (true) {

      if (in.remaining() < 1) return CoderResult.UNDERFLOW;

      in.mark();
      byte b = in.get();
      char c = (char) (b & 0x7f);

      if (CodingErrorAction.REPORT == unmappableCharacterAction()
          && !PrintableCharset.isPrintableChar(c)) {
        /*
        "bug" fix for 359010
        return CoderResult.unmappableForLength(1);
        */
        continue;
      }

      if (out.remaining() < 1) {
        in.reset();
        return CoderResult.OVERFLOW;
      }

      out.put(c);
    }
  }
Esempio n. 6
0
  private CommandArgs<K, V> write(byte[] arg) {
    buffer.mark();

    if (buffer.remaining() < arg.length) {
      int estimate = buffer.remaining() + arg.length + 10;
      realloc(max(buffer.capacity() * 2, estimate));
    }

    while (true) {
      try {
        buffer.put((byte) '$');
        write(arg.length);
        buffer.put(CRLF);
        buffer.put(arg);
        buffer.put(CRLF);
        break;
      } catch (BufferOverflowException e) {
        buffer.reset();
        realloc(buffer.capacity() * 2);
      }
    }

    count++;
    return this;
  }
Esempio n. 7
0
  private void readTagDescriptors() throws IOException {
    int tagDescriptorOffset = tagDescriptorsOffset;
    final byte[] bytes = data.array();
    final Charset utf8 = Charset.forName("utf-8");
    for (int i = 0; i < tagCount; i++) {
      final int dNameOffset = data.getInt(tagDescriptorOffset);
      tagDescriptorOffset += 4;
      final int tagIndex = data.get(tagDescriptorOffset) & 0xff;
      tagDescriptorOffset += 4;

      final int nameOffset = tagNamesOffset + dNameOffset;
      int stringLength = 0;
      while (bytes[nameOffset + stringLength] != 0) {
        stringLength++;
      }

      data.mark();
      data.position(nameOffset);
      data.limit(nameOffset + stringLength);

      names[tagIndex] = utf8.decode(data);

      data.reset();
      data.limit(data.capacity());
    }
  }
  /** Test verifies that the mark, position and limit are unchanged by the checksum operation. */
  public void test_checksum03() {

    byte[] data = new byte[100];
    r.nextBytes(data);

    ByteBuffer buf = ByteBuffer.wrap(data);
    // set the limit.
    buf.limit(20);
    /*
     * set the mark (we have to choose a mark less than the position we will
     * set and test below or the mark will be discarded when we set the
     * position).
     */
    buf.position(9);
    buf.mark();
    // set the position.
    buf.position(12);
    chk.checksum(buf, 0, data.length);
    // verify limit unchanged.
    assertEquals(20, buf.limit());
    // verify position unchanged.
    assertEquals(12, buf.position());
    // reset the buffer to the mark and verify the mark was not changed.
    buf.reset();
    assertEquals(9, buf.position());
  }
Esempio n. 9
0
  private CommandArgs<K, V> write(String arg) {
    int length = arg.length();

    buffer.mark();

    if (buffer.remaining() < length) {
      int estimate = buffer.remaining() + length + 10;
      realloc(max(buffer.capacity() * 2, estimate));
    }

    while (true) {
      try {
        buffer.put((byte) '$');
        write(length);
        buffer.put(CRLF);
        for (int i = 0; i < length; i++) {
          buffer.put((byte) arg.charAt(i));
        }
        buffer.put(CRLF);
        break;
      } catch (BufferOverflowException e) {
        buffer.reset();
        realloc(buffer.capacity() * 2);
      }
    }

    count++;
    return this;
  }
 public void readIDField(ByteBuffer buf, GeoEvent geoEvent, int i)
     throws MessagingException, FieldException {
   // Check if there is more data
   int rm = buf.remaining();
   if (buf.remaining() > 8) {
     buf.mark();
     readString(buf, 1); // Read out semi-colon ;
     String idName = readString(buf, 3); // Read out ID=
     if (idName.equals("ID=") == true) {
       // read until ';' to get value of the ID
       String id = "";
       while (true) {
         String data = readString(buf, 1);
         if (data.equals(";") == false) {
           id += data;
         } else {
           break;
         }
       }
       geoEvent.setField(i++, id);
     } else // no ID= field
     {
       buf.reset(); // set the buf position back to the marked position
     }
   }
 }
 /**
  * Hexdump.
  *
  * @param bb bytebuffer
  * @param offset offset
  * @return String
  */
 public static String hexdump(ByteBuffer bb, int offset) {
   byte[] bit = new byte[bb.remaining()];
   bb.mark();
   bb.get(bit);
   bb.reset();
   return hexdump(bit, offset);
 }
Esempio n. 12
0
  @Override
  public List<Framedata> translateFrame(ByteBuffer buffer)
      throws LimitExedeedException, InvalidDataException {
    List<Framedata> frames = new LinkedList<Framedata>();
    Framedata cur;

    if (incompleteframe != null) {
      // complete an incomplete frame
      while (true) {
        try {
          buffer.mark();
          int available_next_byte_count = buffer.remaining(); // The number of bytes received
          int expected_next_byte_count =
              incompleteframe.remaining(); // The number of bytes to complete the incomplete frame

          if (expected_next_byte_count > available_next_byte_count) {
            // did not receive enough bytes to complete the frame
            incompleteframe.put(buffer.array(), buffer.position(), available_next_byte_count);
            buffer.position(buffer.position() + available_next_byte_count);
            return Collections.emptyList();
          }
          incompleteframe.put(buffer.array(), buffer.position(), expected_next_byte_count);
          buffer.position(buffer.position() + expected_next_byte_count);

          cur = translateSingleFrame((ByteBuffer) incompleteframe.duplicate().position(0));
          frames.add(cur);
          incompleteframe = null;
          break; // go on with the normal frame receival
        } catch (IncompleteException e) {
          // extending as much as suggested
          @SuppressWarnings("unused")
          int oldsize = incompleteframe.limit();
          ByteBuffer extendedframe = ByteBuffer.allocate(checkAlloc(e.getPreferedSize()));
          assert (extendedframe.limit() > incompleteframe.limit());
          incompleteframe.rewind();
          extendedframe.put(incompleteframe);
          incompleteframe = extendedframe;

          return translateFrame(buffer);
        }
      }
    }

    while (buffer.hasRemaining()) { // Read as much as possible full frames
      buffer.mark();
      try {
        cur = translateSingleFrame(buffer);
        frames.add(cur);
      } catch (IncompleteException e) {
        // remember the incomplete data
        buffer.reset();
        int pref = e.getPreferedSize();
        incompleteframe = ByteBuffer.allocate(checkAlloc(pref));
        incompleteframe.put(buffer);
        break;
      }
    }
    return frames;
  }
Esempio n. 13
0
  public static void writeChannel() {
    FileOutputStream fileOut = null;
    FileChannel channel = null;
    try {
      InputStream input = FileChannelIoMain.class.getClassLoader().getResourceAsStream("test.txt");
      byte[] byteBuffer = new byte[1024];

      int size = 0;
      StringBuilder builer = new StringBuilder();
      while ((size = input.read(byteBuffer)) != -1) {
        builer.append(new String(byteBuffer));
      }
      System.out.println(builer.toString());

      File file = new File("./test.txt");
      if (!file.exists()) {
        file.createNewFile();
        file.setWritable(true);
      }
      fileOut = new FileOutputStream(file, true);
      channel = fileOut.getChannel();

      ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
      buffer.putChar('\n');

      buffer.put("我是一个中国人,我的家乡在北京".getBytes("utf-8"));

      buffer.mark();

      buffer.putChar('&');
      buffer.putChar('#');

      buffer.reset();
      buffer.flip();

      // buffer.rewind();

      channel.write(buffer);

      buffer.clear();

    } catch (Throwable e) {
      e.printStackTrace();
    } finally {
      try {
        if (fileOut != null) {
          fileOut.close();
          fileOut = null;
        }
        if (channel != null) {
          channel.close();
          channel = null;
        }
      } catch (Throwable e) {
        e.printStackTrace();
      }
    }
  }
Esempio n. 14
0
  /** Allocate a slice of the given length. */
  public ByteBuffer clone(ByteBuffer buffer) {
    assert buffer != null;
    ByteBuffer cloned = allocate(buffer.remaining());

    cloned.mark();
    cloned.put(buffer.duplicate());
    cloned.reset();
    return cloned;
  }
  /** Allocate a slice of the given length. */
  public ByteBuffer clone(ByteBuffer buffer) {
    assert buffer != null;
    if (buffer.remaining() == 0) return ByteBufferUtil.EMPTY_BYTE_BUFFER;
    ByteBuffer cloned = allocate(buffer.remaining());

    cloned.mark();
    cloned.put(buffer.duplicate());
    cloned.reset();
    return cloned;
  }
Esempio n. 16
0
  /**
   * Decode a region of the buffer under the specified character set if possible.
   *
   * <p>If the byte stream cannot be decoded that way, the platform default is tried and if that too
   * fails, an exception is thrown.
   *
   * @param cs character set to use when decoding the buffer.
   * @param buffer buffer to pull raw bytes from.
   * @param start first position within the buffer to take data from.
   * @param end one position past the last location within the buffer to take data from.
   * @return a string representation of the range <code>[start,end)</code>, after decoding the
   *     region through the specified character set.
   * @throws CharacterCodingException the input is not in any of the tested character sets.
   */
  public static String decodeNoFallback(
      final Charset cs, final byte[] buffer, final int start, final int end)
      throws CharacterCodingException {
    final ByteBuffer b = ByteBuffer.wrap(buffer, start, end - start);
    b.mark();

    // Try our built-in favorite. The assumption here is that
    // decoding will fail if the data is not actually encoded
    // using that encoder.
    //
    try {
      return decode(b, Constants.CHARSET);
    } catch (CharacterCodingException e) {
      b.reset();
    }

    if (!cs.equals(Constants.CHARSET)) {
      // Try the suggested encoding, it might be right since it was
      // provided by the caller.
      //
      try {
        return decode(b, cs);
      } catch (CharacterCodingException e) {
        b.reset();
      }
    }

    // Try the default character set. A small group of people
    // might actually use the same (or very similar) locale.
    //
    final Charset defcs = Charset.defaultCharset();
    if (!defcs.equals(cs) && !defcs.equals(Constants.CHARSET)) {
      try {
        return decode(b, defcs);
      } catch (CharacterCodingException e) {
        b.reset();
      }
    }

    throw new CharacterCodingException();
  }
Esempio n. 17
0
 /** Read a buffer into a Byte array for the given offset and length */
 public static byte[] readBytes(ByteBuffer buffer, int offset, int length) {
   byte[] dest = new byte[length];
   if (buffer.hasArray()) {
     System.arraycopy(buffer.array(), buffer.arrayOffset() + offset, dest, 0, length);
   } else {
     buffer.mark();
     buffer.position(offset);
     buffer.get(dest, 0, length);
     buffer.reset();
   }
   return dest;
 }
Esempio n. 18
0
 @Override
 public byte[] nextPacket(final ByteBuffer byteBuffer) throws ProtocolViolationException {
   if (byteBuffer.remaining() < m_headerSize) return null;
   byteBuffer.mark();
   final int length = NIOUtils.getPacketSizeFromByteBuffer(byteBuffer, m_headerSize, m_bigEndian);
   if (byteBuffer.remaining() >= length) {
     final byte[] packet = new byte[length];
     byteBuffer.get(packet);
     return packet;
   } else {
     byteBuffer.reset();
     return null;
   }
 }
Esempio n. 19
0
 public static String byteBufferToHexString(ByteBuffer bb) {
   bb.mark();
   StringBuilder sb = new StringBuilder();
   int offset = 0;
   while (bb.hasRemaining()) {
     if (offset % 33 == 0) sb.append("\n");
     String s = Integer.toString(bb.get() & 0xFF, 16);
     offset++;
     if (s.length() == 1) sb.append("0");
     sb.append(s.toUpperCase());
   }
   bb.reset();
   return sb.toString();
 }
Esempio n. 20
0
  /**
   * Finds any occurence of <code>what</code> in the backing buffer, starting as position <code>
   * start</code>. The starting position is measured in bytes and the return value is in terms of
   * byte position in the buffer. The backing buffer is not converted to a string for this
   * operation.
   *
   * @return byte position of the first occurence of the search string in the UTF-8 buffer or -1 if
   *     not found
   */
  public int find(String what, int start) {
    try {
      ByteBuffer src = ByteBuffer.wrap(this.bytes, 0, this.length);
      ByteBuffer tgt = encode(what);
      byte b = tgt.get();
      src.position(start);

      while (src.hasRemaining()) {
        if (b == src.get()) { // matching first byte
          src.mark(); // save position in loop
          tgt.mark(); // save position in target
          boolean found = true;
          int pos = src.position() - 1;
          while (tgt.hasRemaining()) {
            if (!src.hasRemaining()) { // src expired first
              tgt.reset();
              src.reset();
              found = false;
              break;
            }
            if (!(tgt.get() == src.get())) {
              tgt.reset();
              src.reset();
              found = false;
              break; // no match
            }
          }
          if (found) return pos;
        }
      }
      return -1; // not found
    } catch (CharacterCodingException e) {
      // can't get here
      e.printStackTrace();
      return -1;
    }
  }
Esempio n. 21
0
  private final SendBuffer acquire(SctpPayload message) {
    final ChannelBuffer src = message.getPayloadBuffer();
    final int streamNo = message.getStreamIdentifier();
    final int protocolId = message.getProtocolIdentifier();

    final int size = src.readableBytes();
    if (size == 0) {
      return EMPTY_BUFFER;
    }

    if (src.isDirect()) {
      return new UnpooledSendBuffer(streamNo, protocolId, src.toByteBuffer());
    }
    if (src.readableBytes() > DEFAULT_PREALLOCATION_SIZE) {
      return new UnpooledSendBuffer(streamNo, protocolId, src.toByteBuffer());
    }

    Preallocation current = this.current;
    ByteBuffer buffer = current.buffer;
    int remaining = buffer.remaining();
    PooledSendBuffer dst;

    if (size < remaining) {
      int nextPos = buffer.position() + size;
      ByteBuffer slice = buffer.duplicate();
      buffer.position(align(nextPos));
      slice.limit(nextPos);
      current.refCnt++;
      dst = new PooledSendBuffer(streamNo, protocolId, current, slice);
    } else if (size > remaining) {
      this.current = current = getPreallocation();
      buffer = current.buffer;
      ByteBuffer slice = buffer.duplicate();
      buffer.position(align(size));
      slice.limit(size);
      current.refCnt++;
      dst = new PooledSendBuffer(streamNo, protocolId, current, slice);
    } else { // size == remaining
      current.refCnt++;
      this.current = getPreallocation0();
      dst = new PooledSendBuffer(streamNo, protocolId, current, current.buffer);
    }

    ByteBuffer dstbuf = dst.buffer;
    dstbuf.mark();
    src.getBytes(src.readerIndex(), dstbuf);
    dstbuf.reset();
    return dst;
  }
Esempio n. 22
0
  private SendBuffer acquire(ChannelBuffer src) {
    final int size = src.readableBytes();
    if (size == 0) {
      return EMPTY_BUFFER;
    }

    if (src instanceof CompositeChannelBuffer && ((CompositeChannelBuffer) src).useGathering()) {
      return new GatheringSendBuffer(src.toByteBuffers());
    }

    if (src.isDirect()) {
      return new UnpooledSendBuffer(src.toByteBuffer());
    }
    if (src.readableBytes() > DEFAULT_PREALLOCATION_SIZE) {
      return new UnpooledSendBuffer(src.toByteBuffer());
    }

    Preallocation current = this.current;
    ByteBuffer buffer = current.buffer;
    int remaining = buffer.remaining();
    PooledSendBuffer dst;

    if (size < remaining) {
      int nextPos = buffer.position() + size;
      ByteBuffer slice = buffer.duplicate();
      buffer.position(align(nextPos));
      slice.limit(nextPos);
      current.refCnt++;
      dst = new PooledSendBuffer(current, slice);
    } else if (size > remaining) {
      this.current = current = getPreallocation();
      buffer = current.buffer;
      ByteBuffer slice = buffer.duplicate();
      buffer.position(align(size));
      slice.limit(size);
      current.refCnt++;
      dst = new PooledSendBuffer(current, slice);
    } else { // size == remaining
      current.refCnt++;
      this.current = getPreallocation0();
      dst = new PooledSendBuffer(current, current.buffer);
    }

    ByteBuffer dstbuf = dst.buffer;
    dstbuf.mark();
    src.getBytes(src.readerIndex(), dstbuf);
    dstbuf.reset();
    return dst;
  }
Esempio n. 23
0
 /** Detects the frame type. This may only work on data originating from a Flash source. */
 public void detectFrameType() {
   if (data != null && data.limit() > 0) {
     data.mark();
     int firstByte = (data.get(0)) & 0xff;
     data.reset();
     int frameType = (firstByte & IoConstants.MASK_VIDEO_FRAMETYPE) >> 4;
     if (frameType == IoConstants.FLAG_FRAMETYPE_KEYFRAME) {
       this.frameType = FrameType.KEYFRAME;
     } else if (frameType == IoConstants.FLAG_FRAMETYPE_INTERFRAME) {
       this.frameType = FrameType.INTERFRAME;
     } else if (frameType == IoConstants.FLAG_FRAMETYPE_DISPOSABLE) {
       this.frameType = FrameType.DISPOSABLE_INTERFRAME;
     }
   }
 }
Esempio n. 24
0
  @Override
  public ByteBuffer createBinaryFrame(Framedata framedata) {
    if (framedata.getOpcode() != Opcode.TEXT) {
      throw new RuntimeException("only text frames supported");
    }

    ByteBuffer pay = framedata.getPayloadData();
    ByteBuffer b = ByteBuffer.allocate(pay.remaining() + 2);
    b.put(START_OF_FRAME);
    pay.mark();
    b.put(pay);
    pay.reset();
    b.put(END_OF_FRAME);
    b.flip();
    return b;
  }
Esempio n. 25
0
  private HandshakeState isFlashEdgeCase(ByteBuffer request) throws IncompleteHandshakeException {
    request.mark();
    if (request.limit() > Draft.FLASH_POLICY_REQUEST.length) {
      return HandshakeState.NOT_MATCHED;
    } else if (request.limit() < Draft.FLASH_POLICY_REQUEST.length) {
      throw new IncompleteHandshakeException(Draft.FLASH_POLICY_REQUEST.length);
    } else {

      for (int flash_policy_index = 0; request.hasRemaining(); flash_policy_index++) {
        if (Draft.FLASH_POLICY_REQUEST[flash_policy_index] != request.get()) {
          request.reset();
          return HandshakeState.NOT_MATCHED;
        }
      }
      return HandshakeState.MATCHED;
    }
  }
Esempio n. 26
0
 /**
  * Gets the content of the ByteBuffer as a byte[] without mutating the buffer (so thread safe) and
  * minimizing GC (i.e. object creation)
  */
 public static byte[] asByteArray(ByteBuffer buf) {
   byte[] result = null;
   if (buf.hasArray() && buf.arrayOffset() == 0 && buf.capacity() == buf.remaining()) {
     result = buf.array();
   } else {
     result = new byte[buf.remaining()];
     if (buf.hasArray()) {
       System.arraycopy(buf.array(), buf.arrayOffset() + buf.position(), result, 0, result.length);
     } else {
       // Direct buffer
       ByteBuffer duplicate = buf.duplicate();
       duplicate.mark();
       duplicate.get(result);
       duplicate.reset();
     }
   }
   return result;
 }
Esempio n. 27
0
  public static Packet read(@NotNull ByteBuffer buf) throws ParseException {
    if (buf == null) {
      throw new IllegalArgumentException("buf must be not null");
    }

    try {
      PacketHeader header = PacketHeader.read(buf);

      if (buf.remaining() != header.size - PacketHeader.HEADER_LENGTH) {
        throw new ParseException(
            "Packet header size = %d, but buf remaining = %d", header.size, buf.remaining());
      }

      if (header.isHello()) {
        buf.mark();
        int connectionFlag = buf.get() & 0xFF;
        buf.position(buf.position() + 2); // skip 2 bytes
        int connectionUptime = buf.get() & 0xFF;
        buf.reset();
        String payload = Utils.readHexString(buf);
        return new PacketHello(header, connectionFlag, connectionUptime, payload);
      }

      ArrayList<Command> commands = new ArrayList<>();
      while (buf.hasRemaining()) {
        commands.add(Command.read(buf));
      }
      return new Packet(header, commands);

    } catch (ParseException ex) {
      throw ex;
    } catch (Throwable ex) {
      buf.rewind();
      throw new ParseException(
          "Can't parse packet %s cause ", Utils.readHexString(buf), ex.getMessage());
    }
  }
 public void reset(ByteBuffer buf) {
   try {
     buf.reset();
   } catch (InvalidMarkException e) {
     buf.mark();
   }
   mBase = buf.array();
   mBaseOffset = buf.arrayOffset();
   mBuf = buf;
   mBuf.order(ByteOrder.LITTLE_ENDIAN);
   mEob = false;
   mRow = null;
   mColumnFamily = null;
   mColumnQualifier = null;
   mValue = null;
   mCellFlag = 0;
   int version = mBuf.getInt();
   if (version != SerializedCellsFlag.VERSION)
     throw new AssertionError(
         "SerializedCells version mismatch, expected "
             + SerializedCellsFlag.VERSION
             + ", got "
             + version);
 }
Esempio n. 29
0
 @Override
 public void reset() throws IOException {
   byteBuffer.reset();
 }
Esempio n. 30
0
 @Override
 public synchronized void reset() throws IOException {
   buffer.reset();
   syncPos();
 }