C# ByteBuffer.get方法代码示例

 /// <summary>
 /// Write the value to result, escaping characters according to the NDN URI
 /// Scheme.
 /// This also adds "..." to a value with zero or more ".".
 /// This does not add a type code prefix such as "sha256digest=".
 /// </summary>
 ///
 /// <param name="value"></param>
 /// <param name="result">The StringBuffer to write to.</param>
 public static void toEscapedString(ByteBuffer value_ren, StringBuilder result)
 {
     bool gotNonDot = false;
     for (int i = value_ren.position(); i < value_ren.limit(); ++i) {
         if (value_ren.get(i) != 0x2e) {
             gotNonDot = true;
             break;
         }
     }
     if (!gotNonDot) {
         // Special case for component of zero or more periods.  Add 3 periods.
         result.append("...");
         for (int i_0 = value_ren.position(); i_0 < value_ren.limit(); ++i_0)
             result.append('.');
     } else {
         for (int i_1 = value_ren.position(); i_1 < value_ren.limit(); ++i_1) {
             int x = ((int) value_ren.get(i_1) & 0xff);
             // Check for 0-9, A-Z, a-z, (+), (-), (.), (_)
             if (x >= 0x30 && x <= 0x39 || x >= 0x41 && x <= 0x5a
                     || x >= 0x61 && x <= 0x7a || x == 0x2b || x == 0x2d
                     || x == 0x2e || x == 0x5f)
                 result.append((char) x);
             else {
                 result.append('%');
                 if (x < 16)
                     result.append('0');
                 result.append(ILOG.J2CsMapping.Util.IlNumber.ToString(x,16).ToUpper());
             }
         }
     }
 }

        /// <summary>
        /// Parse the data from the input buffer recursively and return the root as an
        /// object of a subclass of DerNode.
        /// </summary>
        ///
        /// <param name="inputBuf">position.</param>
        /// <param name="startIdx">The offset into the buffer.</param>
        /// <returns>An object of a subclass of DerNode.</returns>
        public static DerNode parse(ByteBuffer inputBuf, int startIdx)
        {
            int nodeType = ((int) inputBuf.get(startIdx)) & 0xff;
            // Don't increment idx. We're just peeking.

            DerNode newNode;
            if (nodeType == net.named_data.jndn.encoding.der.DerNodeType.Boolean)
                newNode = new DerNode.DerBoolean ();
            else if (nodeType == net.named_data.jndn.encoding.der.DerNodeType.Integer)
                newNode = new DerNode.DerInteger ();
            else if (nodeType == net.named_data.jndn.encoding.der.DerNodeType.BitString)
                newNode = new DerNode.DerBitString ();
            else if (nodeType == net.named_data.jndn.encoding.der.DerNodeType.OctetString)
                newNode = new DerNode.DerOctetString ();
            else if (nodeType == net.named_data.jndn.encoding.der.DerNodeType.Null)
                newNode = new DerNode.DerNull ();
            else if (nodeType == net.named_data.jndn.encoding.der.DerNodeType.ObjectIdentifier)
                newNode = new DerNode.DerOid ();
            else if (nodeType == net.named_data.jndn.encoding.der.DerNodeType.Sequence)
                newNode = new DerNode.DerSequence ();
            else if (nodeType == net.named_data.jndn.encoding.der.DerNodeType.PrintableString)
                newNode = new DerNode.DerPrintableString ();
            else if (nodeType == net.named_data.jndn.encoding.der.DerNodeType.GeneralizedTime)
                newNode = new DerNode.DerGeneralizedTime ();
            else
                throw new DerDecodingException("Unimplemented DER type " + nodeType);

            newNode.decode(inputBuf, startIdx);
            return newNode;
        }

            /// <summary>
            /// Reverse the bytes in buffer starting at position, up to but not including
            /// limit.
            /// </summary>
            ///
            /// <param name="buffer"></param>
            /// <param name="position"></param>
            /// <param name="limit"></param>
            public static void reverse(ByteBuffer buffer, int position, int limit)
            {
                int from = position;
                int to = limit - 1;
                while (from < to) {
                    // swap
                    byte temp = buffer.get(from);
                    buffer.put(from, buffer.get(to));
                    buffer.put(to, temp);

                    --to;
                    ++from;
                }
            }

        /// <summary>
        /// Extract the header from an input buffer and return the size.
        /// </summary>
        ///
        /// <param name="inputBuf">position.</param>
        /// <param name="startIdx">The offset into the buffer.</param>
        /// <returns>The parsed size in the header.</returns>
        protected internal int decodeHeader(ByteBuffer inputBuf, int startIdx)
        {
            int idx = startIdx;

            int nodeType = ((int) inputBuf.get(idx)) & 0xff;
            idx += 1;

            nodeType_ = nodeType;

            int sizeLen = ((int) inputBuf.get(idx)) & 0xff;
            idx += 1;

            DynamicByteBuffer header = new DynamicByteBuffer(10);
            header.ensuredPut((byte) nodeType);
            header.ensuredPut((byte) sizeLen);

            int size = sizeLen;
            bool isLongFormat = (sizeLen & (1 << 7)) != 0;
            if (isLongFormat) {
                int lenCount = sizeLen & ((1 << 7) - 1);
                size = 0;
                while (lenCount > 0) {
                    byte b = inputBuf.get(idx);
                    idx += 1;
                    header.ensuredPut(b);
                    size = 256 * size + (((int) b) & 0xff);
                    lenCount -= 1;
                }
            }

            header_ = header.flippedBuffer();
            return size;
        }

            /// <summary>
            /// Create a new DerInteger from the bytes in the buffer. If bytes represent
            /// a positive integer, you must ensure that the first byte is less than 0x80.
            /// </summary>
            ///
            /// <param name="buffer"></param>
            /// <exception cref="DerEncodingException">if the first byte is not less than 0x80.</exception>
            public DerInteger(ByteBuffer buffer)
                : base(net.named_data.jndn.encoding.der.DerNodeType.Integer)
            {
                if (buffer.remaining() > 0
                        && (((int) buffer.get(buffer.position())) & 0xff) >= 0x80)
                    throw new DerEncodingException(
                            "DerInteger: Negative integers are not currently supported");

                if (buffer.remaining() == 0)
                    payload_.ensuredPut((byte) 0);
                else
                    payload_.ensuredPut(buffer);

                encodeHeader(payload_.position());
            }

        /// <summary>
        /// Continue scanning input starting from offset_ to find the element end.
        /// If the end of the element which started at offset 0 is found, this returns
        /// true and getOffset() is the length of the element.  Otherwise, this returns
        /// false which means you should read more into input and call again.
        /// </summary>
        ///
        /// <param name="input">You have to pass in input each time because the buffer could be reallocated.</param>
        /// <returns>true if found the element end, false if not.</returns>
        public bool findElementEnd(ByteBuffer input)
        {
            if (gotElementEnd_)
                // Someone is calling when we already got the end.
                return true;

            TlvDecoder decoder = new TlvDecoder(input);

            while (true) {
                if (offset_ >= input.limit())
                    // All the cases assume we have some input. Return and wait for more.
                    return false;

                if (state_ == TlvStructureDecoder.READ_TYPE) {
                    int firstOctet = (int) input.get(offset_) & 0xff;
                    offset_ += 1;
                    if (firstOctet < 253)
                        // The value is simple, so we can skip straight to reading the length.
                        state_ = TlvStructureDecoder.READ_LENGTH;
                    else {
                        // Set up to skip the type bytes.
                        if (firstOctet == 253)
                            nBytesToRead_ = 2;
                        else if (firstOctet == 254)
                            nBytesToRead_ = 4;
                        else
                            // value == 255.
                            nBytesToRead_ = 8;

                        state_ = TlvStructureDecoder.READ_TYPE_BYTES;
                    }
                } else if (state_ == TlvStructureDecoder.READ_TYPE_BYTES) {
                    int nRemainingBytes = input.limit() - offset_;
                    if (nRemainingBytes < nBytesToRead_) {
                        // Need more.
                        offset_ += nRemainingBytes;
                        nBytesToRead_ -= nRemainingBytes;
                        return false;
                    }

                    // Got the type bytes. Move on to read the length.
                    offset_ += nBytesToRead_;
                    state_ = TlvStructureDecoder.READ_LENGTH;
                } else if (state_ == TlvStructureDecoder.READ_LENGTH) {
                    int firstOctet_0 = (int) input.get(offset_) & 0xff;
                    offset_ += 1;
                    if (firstOctet_0 < 253) {
                        // The value is simple, so we can skip straight to reading
                        //  the value bytes.
                        nBytesToRead_ = firstOctet_0;
                        if (nBytesToRead_ == 0) {
                            // No value bytes to read. We're finished.
                            gotElementEnd_ = true;
                            return true;
                        }

                        state_ = TlvStructureDecoder.READ_VALUE_BYTES;
                    } else {
                        // We need to read the bytes in the extended encoding of
                        //  the length.
                        if (firstOctet_0 == 253)
                            nBytesToRead_ = 2;
                        else if (firstOctet_0 == 254)
                            nBytesToRead_ = 4;
                        else
                            // value == 255.
                            nBytesToRead_ = 8;

                        // We need to use firstOctet in the next state.
                        firstOctet_ = firstOctet_0;
                        state_ = TlvStructureDecoder.READ_LENGTH_BYTES;
                    }
                } else if (state_ == TlvStructureDecoder.READ_LENGTH_BYTES) {
                    int nRemainingBytes_1 = input.limit() - offset_;
                    if (!useHeaderBuffer_ && nRemainingBytes_1 >= nBytesToRead_) {
                        // We don't have to use the headerBuffer. Set nBytesToRead.
                        decoder.seek(offset_);

                        nBytesToRead_ = decoder.readExtendedVarNumber(firstOctet_);
                        // Update offset_ to the decoder's offset after reading.
                        offset_ = decoder.getOffset();
                    } else {
                        useHeaderBuffer_ = true;

                        int nNeededBytes = nBytesToRead_ - headerBuffer_.position();
                        if (nNeededBytes > nRemainingBytes_1) {
                            // We can't get all of the header bytes from this input.
                            // Save in headerBuffer.
                            if (headerBuffer_.position() + nRemainingBytes_1 > headerBuffer_
                                    .limit())
                                // We don't expect this to happen.
//.........这里部分代码省略.........

        /// <summary>
        /// Set data to the host.
        /// </summary>
        /// <param name="data">The buffer of data to send.  This reads from position() to 
        /// limit(), but does not change the position.</param>
        public override void send(ByteBuffer data)
        {
            if (socket_ == null)
            throw new System.IO.IOException
              ("Cannot send because the socket is not open.  Use connect.");

              // ByteBuffer is readonly so we can't call array(), and we can't do a low-level
              //   operation on the array, so we have to copy.
              var buffer = new byte[data.remaining()];
              int savePosition = data.position();
              data.get(buffer);
              data.position(savePosition);

              socket_.Send(buffer);
        }

		private Bitmap decodeToBitmap(ByteBuffer jpegData, int sampleSize)
		{
			sbyte[] jpegDataArray = new sbyte[jpegData.remaining()];
			jpegData.get(jpegDataArray);
			jpegData.rewind();

			BitmapFactory.Options option = new BitmapFactory.Options();
			option.inSampleSize = sampleSize;

			return BitmapFactory.decodeByteArray(jpegDataArray, 0, jpegDataArray.Length, option);
		}

 /// <summary>
 /// Write a hex string of the contents of buffer from position to limit to the
 /// output.
 /// </summary>
 ///
 /// <param name="buffer">The buffer.</param>
 /// <returns>A string of hex bytes.</returns>
 /// <param name="output">The StringBuffer to write to.</param>
 public static void toHex(ByteBuffer buffer, StringBuilder output)
 {
     for (int i = buffer.position(); i < buffer.limit(); ++i) {
         String hex = ILOG.J2CsMapping.Util.IlNumber.ToString((int) buffer.get(i) & 0xff,16);
         if (hex.Length <= 1)
             // Append the leading zero.
             output.append("0");
         output.append(hex);
     }
 }

        public void onReceivedElement(ByteBuffer element)
        {
            LpPacket lpPacket = null;
            if (element.get(0) == net.named_data.jndn.encoding.tlv.Tlv.LpPacket_LpPacket) {
                // Decode the LpPacket and replace element with the fragment.
                lpPacket = new LpPacket();
                // Set copy false so that the fragment is a slice which will be copied below.
                // The header fields are all integers and don't need to be copied.
                net.named_data.jndn.encoding.TlvWireFormat.get().decodeLpPacket(lpPacket, element, false);
                element = lpPacket.getFragmentWireEncoding().buf();
            }

            // First, decode as Interest or Data.
            Interest interest = null;
            Data data = null;
            if (element.get(0) == net.named_data.jndn.encoding.tlv.Tlv.Interest || element.get(0) == net.named_data.jndn.encoding.tlv.Tlv.Data) {
                TlvDecoder decoder = new TlvDecoder(element);
                if (decoder.peekType(net.named_data.jndn.encoding.tlv.Tlv.Interest, element.remaining())) {
                    interest = new Interest();
                    interest.wireDecode(element, net.named_data.jndn.encoding.TlvWireFormat.get());

                    if (lpPacket != null)
                        interest.setLpPacket(lpPacket);
                } else if (decoder.peekType(net.named_data.jndn.encoding.tlv.Tlv.Data, element.remaining())) {
                    data = new Data();
                    data.wireDecode(element, net.named_data.jndn.encoding.TlvWireFormat.get());

                    if (lpPacket != null)
                        data.setLpPacket(lpPacket);
                }
            }

            if (lpPacket != null) {
                // We have decoded the fragment, so remove the wire encoding to save memory.
                lpPacket.setFragmentWireEncoding(new Blob());

                NetworkNack networkNack = net.named_data.jndn.NetworkNack.getFirstHeader(lpPacket);
                if (networkNack != null) {
                    if (interest == null)
                        // We got a Nack but not for an Interest, so drop the packet.
                        return;

                    ArrayList<PendingInterestTable.Entry> pitEntries = new ArrayList<PendingInterestTable.Entry>();
                    pendingInterestTable_.extractEntriesForNackInterest(interest,
                            pitEntries);
                    for (int i = 0; i < pitEntries.Count; ++i) {
                        PendingInterestTable.Entry pendingInterest = pitEntries[i];
                        try {
                            pendingInterest.getOnNetworkNack().onNetworkNack(
                                    pendingInterest.getInterest(), networkNack);
                        } catch (Exception ex) {
                            logger_.log(ILOG.J2CsMapping.Util.Logging.Level.SEVERE, "Error in onNack", ex);
                        }
                    }

                    // We have processed the network Nack packet.
                    return;
                }
            }

            // Now process as Interest or Data.
            if (interest != null) {
                // Quickly lock and get all interest filter callbacks which match.
                ArrayList matchedFilters = new ArrayList();
                interestFilterTable_.getMatchedFilters(interest, matchedFilters);

                // The lock on interestFilterTable_ is released, so call the callbacks.
                for (int i_0 = 0; i_0 < matchedFilters.Count; ++i_0) {
                    InterestFilterTable.Entry entry = (InterestFilterTable.Entry) matchedFilters[i_0];
                    try {
                        entry.getOnInterest().onInterest(
                                entry.getFilter().getPrefix(), interest,
                                entry.getFace(), entry.getInterestFilterId(),
                                entry.getFilter());
                    } catch (Exception ex_1) {
                        logger_.log(ILOG.J2CsMapping.Util.Logging.Level.SEVERE, "Error in onInterest", ex_1);
                    }
                }
            } else if (data != null) {
                ArrayList<PendingInterestTable.Entry> pitEntries_2 = new ArrayList<PendingInterestTable.Entry>();
                pendingInterestTable_.extractEntriesForExpressedInterest(data,
                        pitEntries_2);
                for (int i_3 = 0; i_3 < pitEntries_2.Count; ++i_3) {
                    PendingInterestTable.Entry pendingInterest_4 = pitEntries_2[i_3];
                    try {
                        pendingInterest_4.getOnData().onData(
                                pendingInterest_4.getInterest(), data);
                    } catch (Exception ex_5) {
                        logger_.log(ILOG.J2CsMapping.Util.Logging.Level.SEVERE, "Error in onData", ex_5);
                    }
                }
            }
        }

        /// <summary>
        /// Compute the HMAC with SHA-256 of data, as defined in
        /// http://tools.ietf.org/html/rfc2104#section-2 .
        /// </summary>
        ///
        /// <param name="key">The key byte array.</param>
        /// <param name="data">The input byte buffer. This does not change the position.</param>
        /// <returns>The HMAC result.</returns>
        public static byte[] computeHmacWithSha256(byte[] key, ByteBuffer data)
        {
            using (var hmac = new HMACSHA256(key)) {
            // Copy the buffer to an array.
            var array = new byte[data.remaining()];
            int savePosition = data.position();
            data.get(array);
            data.position(savePosition);

            return hmac.ComputeHash(array);
              }
        }

        /// <summary>
        /// Compute the sha-256 digest of data.
        /// </summary>
        ///
        /// <param name="data">The input byte buffer. This does not change the position.</param>
        /// <returns>The digest.</returns>
        public static byte[] digestSha256(ByteBuffer data)
        {
            // Copy the buffer to an array.
              var array = new byte[data.remaining()];
              int savePosition = data.position();
              data.get(array);
              data.position(savePosition);

              return sha256_.ComputeHash(array);
        }

        /**
	     * 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;
        }

		private Bitmap decodeToBitmap(ByteBuffer jpegData, int sampleSize, int cropWidth)
		{
			sbyte[] jpegDataArray = new sbyte[jpegData.remaining()];
			jpegData.get(jpegDataArray);
			jpegData.rewind();

			BitmapFactory.Options option = new BitmapFactory.Options();
			option.inSampleSize = sampleSize;

			if (cropWidth == 0)
			{
				return BitmapFactory.decodeByteArray(jpegDataArray, 0, jpegDataArray.Length, option);
			}

			Bitmap bitmap = null;
			try
			{
				BitmapRegionDecoder decoder = BitmapRegionDecoder.newInstance(jpegDataArray, 0, jpegDataArray.Length, true);

				int cropHeight = cropWidth * decoder.Height / decoder.Width;
				Rect cropRect = new Rect(decoder.Width / 2 - cropWidth, decoder.Height / 2 - cropHeight, decoder.Width / 2 + cropWidth, decoder.Height / 2 + cropHeight);

				bitmap = decoder.decodeRegion(cropRect, option);
			}
			catch (IOException e)
			{
				Console.WriteLine(e.ToString());
				Console.Write(e.StackTrace);
			}

			return bitmap;
		}