Esempio n. 1
0
 /// <summary>
 /// 小数据流转换
 /// </summary>
 /// <param name="stream"></param>
 /// <returns></returns>
 public static System.IO.Stream ToTinyStream(this Java.IO.InputStream stream)
 {
     using (stream)
         using (System.IO.MemoryStream memoryStream = new System.IO.MemoryStream())
         {
             byte[] buffer = fastCSharp.memoryPool.TinyBuffers.Get();
             try
             {
                 do
                 {
                     int length = stream.Read(buffer);
                     if (length == -1)
                     {
                         break;
                     }
                     if (length != 0)
                     {
                         memoryStream.Write(buffer, 0, length);
                     }
                 }while (true);
             }
             finally { fastCSharp.memoryPool.TinyBuffers.Push(ref buffer); }
             return(new System.IO.MemoryStream(memoryStream.GetBuffer(), 0, (int)memoryStream.Position, false));
         }
 }
Esempio n. 2
0
        public override int Read(byte[] buffer, int offset, int count)
        {
            int res = BaseInputStream.Read(buffer, offset, count);

            if (res == -1)
            {
                return(0);
            }
            return(res);
        }
Esempio n. 3
0
 /// <summary>
 /// Read a sequence of bytes from this stream and advance the position of this stream.
 /// </summary>
 /// <param name="buffer">Destination</param>
 /// <param name="offset">Offset within the buffer</param>
 /// <param name="count">Number of bytes to read.</param>
 /// <returns>The total number of bytes read or 0 if the end of the stream has been reached.</returns>
 public override int Read(byte[] buffer, int offset, int count)
 {
     while (true)
     {
         var rc = stream.Read(buffer, offset, count);
         if (rc < 0)
         {
             return(0); // End of stream
         }
         if (rc > 0)
         {
             position += rc;
             return(rc);
         }
     }
 }
Esempio n. 4
0
        //
        // Exception audit:
        //
        //  Verdict
        //    Exception wrapping is required.
        //
        //  Rationale
        //    `java.io.InputStream.read(byte[], int, int)` throws an exception, see:
        //
        //     https://developer.android.com/reference/java/io/InputStream?hl=en#read(byte%5B%5D,%20int,%20int)
        //
        public override int Read(byte[] buffer, int offset, int count)
        {
            int res;

            try {
                res = BaseInputStream.Read(buffer, offset, count);
            } catch (Java.IO.IOException ex) when(JNIEnv.ShouldWrapJavaException(ex))
            {
                throw new IOException(ex.Message, ex);
            }

            if (res == -1)
            {
                return(0);
            }
            return(res);
        }
Esempio n. 5
0
 public static int read(this Java.IO.InputStream stream, byte[] b)
 {
     return(stream.Read(b));
 }