public InputStreamReader(IInputStream stream, uint bufferSize)
        {
            _reader = new DataReader(stream);
            _reader.InputStreamOptions = InputStreamOptions.Partial;

            _bufferSize = bufferSize;
        }

 public PushAttachmentData(String contentType, IInputStream data, ulong dataSize, byte[] key)
 {
     this.contentType = contentType;
     this.data = data;
     this.dataSize = dataSize;
     this.key = key;
 }

 public bool ReadStringFromInputStream(IInputStream inputStream, List<string> messages, out string s)
 {
     var bytesCollection = new List<byte[]>();
     var bytes = new byte[Environment.SystemPageSize];
     while (true)
     {
         var bytesRead = inputStream.Read(bytes, _timeout);
         if (bytesRead <= 0) break;
         var bytesCopy = new byte[bytesRead];
         Buffer.BlockCopy(bytes, 0, bytesCopy, 0, bytesRead);
         bytesCollection.Add(bytesCopy);
     }
     var bytesCount = bytesCollection.Sum(bytesChunk => bytesChunk.Length);
     bytes = new byte[bytesCount];
     var offset = 0;
     foreach (var bytesChunk in bytesCollection)
     {
         Buffer.BlockCopy(bytesChunk, 0, bytes, offset, bytesChunk.Length);
         offset += bytesChunk.Length;
     }
     try
     {
         s = _encoding.GetString(bytes);
     }
     catch (Exception e)
     {
         messages.Add(e.ToString());
         s = null;
         return false;
     }
     return true;
 }

		public DataReader (IInputStream inputStream)
		{
			if (inputStream == null)
				throw new ArgumentNullException ("inputStream");

			throw new NotImplementedException();
		}

 private static async Task<TileSet> LoadTileSetAsync(IInputStream stream)
 {
     using (var reader = new StreamReader(stream.AsStreamForRead()))
     {
         return JsonConvert.DeserializeObject<TileSet>(await reader.ReadToEndAsync());
     }
 }

 internal Reader(
     IInputStream stream,
     files.File file
     )
 {
     this.parser = new FileParser(stream, file);
 }

        /// <summary>
        /// Encrypt an input stream and output to another stream
        /// </summary>
        /// <param name="inStream"></param>
        /// <param name="outStream"></param>
        /// <param name="userDescriptor"></param>
        /// <returns></returns>
        public static async Task ProtectStreamToStream(IInputStream inStream, IOutputStream outStream, string userDescriptor)
        {
            // Create a DataProtectionProvider object for the specified descriptor.
            DataProtectionProvider Provider = new DataProtectionProvider(userDescriptor);

            await Provider.ProtectStreamAsync(inStream, outStream);

        }

 public LengthMarkedBufferedInputStream(IInputStream input)
 {
     this.input = input;
     buf = new byte[InitialBufferSize];
     count = 0;
     markedLength = -1;
     markedIndex = -1;
 }

   internal FileParser(
 IInputStream stream,
 files.File file
 )
       : base(stream)
   {
       this.file = file;
   }

        internal AfmParser(
      IInputStream fontData
      )
        {
            FontData = fontData;

              Load();
        }

        /// <summary>
        /// Decrypt an input stream and output to another stream
        /// </summary>
        /// <param name="readStream"></param>
        /// <param name="outStream"></param>
        /// <returns></returns>
        public static async Task DecryptStream(IInputStream readStream, IOutputStream outStream, string userDescriptor)
        {
            // Create a DataProtectionProvider object for the specified descriptor.
            DataProtectionProvider Provider = new DataProtectionProvider(userDescriptor);

            await Provider.UnprotectStreamAsync(readStream, outStream);     // decrypt and output

            return;
        }

        public void Open(IInputStream input, IOutputStream output)
        {
            m_DataReader = new DataReader(input);
            m_DataReader.ByteOrder = ByteOrder.LittleEndian;
            m_Reader.Reader = m_DataReader;

            m_DataWriter = new DataWriter(output);
            m_DataWriter.ByteOrder = ByteOrder.LittleEndian;
            m_Writer.Writer = m_DataWriter;
        }

        public HashedInputStream(IInputStream stream)
        {
            if (stream == null)
                throw new ArgumentNullException("stream");

            _stream = stream;
            _sha = HashAlgorithmProvider
                .OpenAlgorithm(HashAlgorithmNames.Sha256)
                .CreateHash();
        }

        protected void writeStream(IInputStream input)// throws IOException
        {
            /*byte[] buffer = new byte[4096];
            int read;

            while ((read = input.read(buffer)) != -1) {
                output.write(buffer, 0, read);
            }

            input.close();*/
            throw new NotImplementedException();
        }

        internal async Task<HttpRequest> ParseRequestStream(IInputStream requestStream)
        {
            var httpStream = new HttpRequestStream(requestStream);
            var request = new HttpRequest();

            try
            {
                var stream = await httpStream.ReadAsync(BUFFER_SIZE, InputStreamOptions.Partial);
                byte[] streamData = stream.Data;

                var requestPipeline = GetPipeline();
                using (var pipeLineEnumerator = requestPipeline.GetEnumerator())
                {
                    pipeLineEnumerator.MoveNext();
                    bool requestComplete = false;

                    while (!requestComplete)
                    {
                        pipeLineEnumerator.Current.HandleRequestPart(streamData, request);
                        streamData = pipeLineEnumerator.Current.UnparsedData;

                        if (pipeLineEnumerator.Current.IsFinished)
                        {
                            if (!pipeLineEnumerator.Current.IsSucceeded ||
                                !pipeLineEnumerator.MoveNext())
                            {
                                break;
                            }
                        }
                        else
                        {
                            var newStreamdata = await httpStream.ReadAsync(BUFFER_SIZE, InputStreamOptions.Partial);

                            if (!newStreamdata.ReadSuccessful)
                            {
                                break;
                            }

                            streamData = streamData.ConcatArray(newStreamdata.Data);
                        }
                    }
                }

                request.IsComplete = requestPipeline.All(p => p.IsSucceeded);
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.Message);
            }

            return request;
        }

 /// <summary>
 /// This class implements the upload operation on Windows 8 using the background uploader.
 /// </summary>
 /// <remarks>This constructor is used when uploading a stream created by the application.</remarks>
 public TailoredUploadOperation(
     LiveConnectClient client,
     Uri url,
     string fileName,
     IInputStream inputStream,
     OverwriteOption option,
     IProgress<LiveOperationProgress> progress,
     SynchronizationContextWrapper syncContext)
     : this(client, url, fileName, option, progress, syncContext)
 {
     Debug.Assert(inputStream != null, "inputStream is null.");
     this.InputStream = inputStream;
 }

        /// <summary>
        /// This class implements the upload operation on Windows 8 using the background uploader.
        /// </summary>
        /// <remarks>This constructor is used when uploading a stream created by the application.</remarks>
        public CreateBackgroundUploadOperation(
            LiveConnectClient client,
            Uri url,
            string fileName,
            IInputStream inputStream,
            OverwriteOption option)
            : base(client, url, ApiMethod.Upload, null, null)
        {
            Debug.Assert(inputStream != null, "inputStream is null.");

            this.InputStream = inputStream;
            this.FileName = fileName;
            this.OverwriteOption = option;
        }

		/// <exception cref="System.IO.IOException"></exception>
		protected virtual void Copy(IInputStream rawin, Socket4Adapter sock, bool update)
		{
			BufferedInputStream @in = new BufferedInputStream(rawin);
			byte[] buffer = new byte[BlobImpl.CopybufferLength];
			int bytesread = -1;
			while ((bytesread = rawin.Read(buffer)) >= 0)
			{
				sock.Write(buffer, 0, bytesread);
				if (update)
				{
					_currentByte += bytesread;
				}
			}
			@in.Close();
		}

        public StreamWatcher( IInputStream stream )
        {
            if ( stream == null ) throw new ArgumentNullException( "stream" );

            ReadSize = 256;

            _reader = new DataReader( stream )
            {
                ByteOrder = ByteOrder.LittleEndian,
                InputStreamOptions = InputStreamOptions.Partial
            };

            Task.Factory.StartNew( CheckForData, _tokenSource.Token, TaskCreationOptions.LongRunning,
                TaskScheduler.Default );
        }

 private async Task<StringBuilder> ReadInputStream(IInputStream InputStream)
 {
     StringBuilder requestbuilder = new StringBuilder();
     using (IInputStream input = InputStream)
     {
         byte[] data = new byte[BufferSize];
         IBuffer buffer = data.AsBuffer();
         uint dataRead = BufferSize;
         while (dataRead == BufferSize)
         {
             await input.ReadAsync(buffer, BufferSize, InputStreamOptions.Partial);
             requestbuilder.Append(Encoding.UTF8.GetString(data, 0, data.Length));
             dataRead = buffer.Length;
         }
     }
     return requestbuilder;
 }