示例#1
0
jint ByteChannel::read(jobject destination)
{
  const ByteBuffer::ClassImpl& bufimpl = ByteBuffer::impl(m_env);

  const jint remaining = get_remaining(m_env, destination,
                                       bufimpl.m_mid_get_remaining);
  if (!remaining)
    {
      // No space in the buffer; don't try to read anything.
      return 0;
    }

  const jint position = get_position(m_env, destination,
                                     bufimpl.m_mid_get_position);

  jint bytes_read = 0;
  void* data = m_env.GetDirectBufferAddress(destination);
  if (data)
    {
      data = static_cast<char*>(data) + position;
      bytes_read = m_reader(m_env, data, remaining);
    }
  else
    {
      // It was not a direct buffer ... see if it has an array.
      jbyteArray raw_array = get_array(m_env, destination,
                                       bufimpl.m_mid_has_array,
                                       bufimpl.m_mid_get_array);
      if (raw_array)
        {
          const jint array_offset = get_array_offset(
              m_env, destination,
              bufimpl.m_mid_get_array_offset);
          ByteArray array(m_env, raw_array);
          ByteArray::MutableContents contents(array);
          data = contents.data();
          data = static_cast<char*>(data) + position + array_offset;
          bytes_read = m_reader(m_env, data, remaining);
        }
    }
  if (data)
    {
      if (bytes_read > 0)
        set_position(m_env, destination,
                     bufimpl.m_mid_set_position,
                     position + bytes_read);
      return bytes_read;
    }

  // No accessible array, either. Oh well. Create a byte array and
  // push it into the buffer.
  ByteArray array(m_env, remaining);
  ByteArray::MutableContents contents(array);
  bytes_read = m_reader(m_env, contents.data(), contents.length());
  if (bytes_read > 0)
    put_bytearray(m_env, destination,
                  bufimpl.m_mid_put_bytearray,
                  array, bytes_read);
  return bytes_read;
}
示例#2
0
jint ByteChannel::write(jobject source)
{
  const ByteBuffer::ClassImpl& bufimpl = ByteBuffer::impl(m_env);

  const jint remaining = get_remaining(m_env, source,
                                       bufimpl.m_mid_get_remaining);
  if (!remaining)
    {
      // No data in the buffer; don't try to write anything.
      return 0;
    }

  const jint position = get_position(m_env, source,
                                     bufimpl.m_mid_get_position);

  jint bytes_written = 0;
  const void* data = m_env.GetDirectBufferAddress(source);
  if (data)
    {
      data = static_cast<const char*>(data) + position;
      bytes_written = m_writer(m_env, data, remaining);
    }
  else
    {
      // It was not a direct buffer ... see if it has an array.
      jbyteArray raw_array = get_array(m_env, source,
                                       bufimpl.m_mid_has_array,
                                       bufimpl.m_mid_get_array);
      if (raw_array)
        {
          const jint array_offset = get_array_offset(
              m_env, source,
              bufimpl.m_mid_get_array_offset);
          const ByteArray array(m_env, raw_array);
          ByteArray::Contents contents(array);
          data = contents.data();
          data = static_cast<const char*>(data) + position + array_offset;
          bytes_written = m_writer(m_env, data, remaining);
        }
    }
  if (data)
    {
      if (bytes_written > 0)
        set_position(m_env, source,
                     bufimpl.m_mid_set_position,
                     position + bytes_written);
      return bytes_written;
    }

  // No accessible array, either. Oh well. Get an array from the
  // buffer and read data from that.
  ByteArray array(m_env, remaining);
  get_bytearray(m_env, source,
                bufimpl.m_mid_get_bytearray,
                array);
  ByteArray::Contents contents(array);
  bytes_written = m_writer(m_env, contents.data(), contents.length());
  return bytes_written;
}
示例#3
0
   bool data_stream::read_array(std::vector<uint8>& buf)
   {
      if (get_remaining() > 1024U*1024U*1024U)
         return false;

      uint32 bytes_to_read = static_cast<uint32>(get_remaining());
      if (!bytes_to_read)
      {
         buf.resize(0);
         return true;
      }

      if (buf.size() < bytes_to_read)
         buf.resize(bytes_to_read);
      
      return read(&buf[0], bytes_to_read) == bytes_to_read;
   }
示例#4
0
   bool data_stream::read_array(vector<uint8>& buf)
   {
      if (buf.size() < get_remaining())
      {
         if (get_remaining() > 1024U*1024U*1024U)
            return false;

         buf.resize((uint)get_remaining());
      }

      if (!get_remaining())
      {
         buf.resize(0);
         return true;
      }

      return read(&buf[0], buf.size()) == buf.size();
   }
int DXBC_Reader::get_int32()
{
	if (get_remaining() < 4)
		throw Exception("Unknown DXBC format");

	int value = *(read_ptr++);
	value |= *(read_ptr++) << 8;
	value |= *(read_ptr++) << 16;
	value |= *(read_ptr++) << 24;
	return value;
}
示例#6
0
    bool data_stream::read_array(vector<uint8> &buf)
    {
        if (buf.size() < get_remaining())
        {
            //if (get_remaining() > 1024U*1024U*1024U)
            if (get_remaining() > static_cast<uint64_t>(cINT32_MAX))
                return false;

            if (!buf.try_resize(static_cast<uint>(get_remaining())))
                return false;
        }

        if (!get_remaining())
        {
            buf.resize(0);
            return true;
        }

        return read(&buf[0], buf.size()) == buf.size();
    }
const char * DXBC_Reader::get_string(int offset)
{
	if ((offset < 0) || (offset > get_remaining()))
		throw Exception("Unknown DXBC format");

	const char *str_ptr = (const char *) read_ptr;
	str_ptr += offset;

	// Validate string .. check for end NUL
	const unsigned char *check_ptr = (const unsigned char *) str_ptr;
	while(*check_ptr)
	{
		check_ptr++;
		if (check_ptr >= end_ptr)
			throw Exception("Unknown DXBC format");
	}

	return str_ptr;

}
void DXBC_Reader::skip_bytes(int size)
{
	if (get_remaining() < size)
		throw Exception("Unknown DXBC format");
	read_ptr+=size;
}