C# ByteBuffer.array方法代码示例

 // Doubles the size of the ByteBuffer, and copies the old data towards the
 // end of the new buffer (since we build the buffer backwards).
 internal virtual ByteBuffer growByteBuffer(ByteBuffer bb)
 {
     sbyte[] old_buf = bb.array();
     int old_buf_size = old_buf.Length;
     if ((old_buf_size & 0xC0000000) != 0) // Ensure we don't grow beyond what fits in an int.
     {
         throw new AssertionError("FlatBuffers: cannot grow buffer beyond 2 gigabytes.");
     }
     int new_buf_size = old_buf_size << 1;
     sbyte[] new_buf = new sbyte[new_buf_size];
     Array.Copy(old_buf, 0, new_buf, new_buf_size - old_buf_size, old_buf_size);
     ByteBuffer nbb = newByteBuffer(new_buf);
     nbb.position(bb.position());
     return nbb;
 }

 public void output(ByteBuffer buffer)
 {
     _output.Write(buffer.array(), buffer.arrayOffset() + buffer.position(), buffer.remaining());
 }

 // Prepare to write an element of `size` after `additional_bytes`
 // have been written, e.g. if you write a string, you need to align such
 // the int length field is aligned to SIZEOF_INT, and the string data follows it
 // directly.
 // If all you need to do is align, `additional_bytes` will be 0.
 public virtual void prep(int size, int additional_bytes)
 {
     // Track the biggest thing we've ever aligned to.
     if (size > minalign)
     {
         minalign = size;
     }
     // Find the amount of alignment needed such that `size` is properly
     // aligned after `additional_bytes`
     int align_size = ((~(bb.array().length - space + additional_bytes)) + 1) & (size - 1);
     // Reallocate the buffer if needed.
     while (space < align_size + size + additional_bytes)
     {
         int old_buf_size = bb.array().length;
         bb = growByteBuffer(bb);
         space += bb.array().length - old_buf_size;
     }
     pad(align_size);
 }

        /**
	     * Send an object through the telemetry link.
	     * @throws IOException
	     * @param[in] obj Object handle to send
	     * @param[in] type Transaction type \return Success (true), Failure (false)
	     */
        private bool transmitSingleObject(UAVObject obj, int type, bool allInstances)
        {
            int length;
            int allInstId = uavConsts.ALL_INSTANCES;

            ByteBuffer bbuf = new ByteBuffer(uavConsts.MAX_PACKET_LENGTH);
            
            // Determine data length
            if (type == uavConsts.TYPE_OBJ_REQ || type == uavConsts.TYPE_ACK)
            {
                length = 0;
            }
            else
            {
                length = obj.getNumBytes();
            }

            // Setup type and object id fields
            bbuf.put((byte)(uavConsts.SYNC_VAL & 0xff));
            bbuf.put((byte)(type & 0xff));
            bbuf.putShort((UInt16)(length + 2 /* SYNC, Type */+ 2 /* Size */+ 4 /* ObjID */+ (obj
                            .isSingleInstance() ? 0 : 2)));
            bbuf.putUint32((UInt32)obj.getObjID());

            // Setup instance ID if one is required
            if (!obj.isSingleInstance())
            {
                // Check if all instances are requested
                if (allInstances)
                    bbuf.putShort((UInt16)(allInstId & 0xffff));
                else
                    bbuf.putShort((UInt16)(obj.getInstID() & 0xffff));
            }

            // Check length
            if (length >= uavConsts.MAX_PAYLOAD_LENGTH)
                return false;

            // Copy data (if any)
            if (length > 0)
                try
                {
                    if (obj.pack(bbuf) == 0)
                        return false;
                }
                catch (Exception e)
                {
                    // TODO Auto-generated catch block
                    Debug.Write(e.Message);
                    return false;
                }

            // Calculate checksum
            bbuf.put((byte)(CRC.updateCRC(0, bbuf.array(), bbuf.position()) & 0xff));

            int packlen = bbuf.position();
            bbuf.position(0);
            byte[] dst = new byte[packlen];
            bbuf.get(dst, 0, packlen);

            if (type == uavConsts.TYPE_OBJ_ACK || type == uavConsts.TYPE_OBJ_REQ)
            {
                // Once we send a UAVTalk packet that requires an ack or object let's set up
                // the transaction here
                setupTransaction(obj, allInstances, type);
            }

            ch.write(dst);


            // Update stats
            ++txStats.Objects;
            txStats.Bytes += bbuf.position();
            txStats.ObjectBytes += length;

            // Done
            return true;
        }