public DataWriter (IOutputStream outputStream)
		{
			if (outputStream == null)
				throw new ArgumentNullException ("outputStream");

			throw new NotImplementedException();
		}

        private async Task WriteResponseAsync(string[] requestTokens, IOutputStream outstream)
        {
            // NOTE: If you change the respBody format, change the Content-Type (below) accordingly
            //string respBody = weatherData.HTML;
            //string respBody = weatherData.XML;
            string respBody = weatherData.JSON;

            string htmlCode = "200 OK";

            using (Stream resp = outstream.AsStreamForWrite())
            {
                byte[] bodyArray = Encoding.UTF8.GetBytes(respBody);
                MemoryStream stream = new MemoryStream(bodyArray);

                // NOTE: If you change the respBody format (above), change the Content-Type accordingly
                string header = string.Format("HTTP/1.1 {0}\r\n" +
                                              //"Content-Type: text/html\r\n" + // HTML only
                                              //"Content-Type: text/xml\r\n" +  // XML only
                                              "Content-Type: text/json\r\n" + // JSON only
                                              "Content-Length: {1}\r\n" +
                                              "Connection: close\r\n\r\n",
                                              htmlCode, stream.Length);

                byte[] headerArray = Encoding.UTF8.GetBytes(header);
                await resp.WriteAsync(headerArray, 0, headerArray.Length);
                await stream.CopyToAsync(resp);
                await resp.FlushAsync();
            }
        }

 public override void WriteTo(
     IOutputStream stream,
     Document context
     )
 {
     stream.Write(value);
 }

   internal CompressedWriter(
 files.File file,
 IOutputStream stream
 )
       : base(file, stream)
   {
   }

        public bool Initialize(IOutputStream _stream)
        {
            stream = _stream;

            Print("Controller.Initialize is success.");
            return true;
        }

        /// <summary>
        /// Register output stream.
        /// </summary>
        /// <param name="output_stream"></param>
        public static void RegisterOutputStream(
            IOutputStream output_stream)
        {
            OutputStreamHost.InitializeIfNeeded();

            _output_streams.Add(output_stream);
        }

		/// <exception cref="System.IO.IOException"></exception>
		protected virtual void Copy(Socket4Adapter sock, IOutputStream rawout, int length
			, bool update)
		{
			BufferedOutputStream @out = new BufferedOutputStream(rawout);
			byte[] buffer = new byte[BlobImpl.CopybufferLength];
			int totalread = 0;
			while (totalread < length)
			{
				int stilltoread = length - totalread;
				int readsize = (stilltoread < buffer.Length ? stilltoread : buffer.Length);
				int curread = sock.Read(buffer, 0, readsize);
				if (curread < 0)
				{
					throw new IOException();
				}
				@out.Write(buffer, 0, curread);
				totalread += curread;
				if (update)
				{
					_currentByte += curread;
				}
			}
			@out.Flush();
			@out.Close();
		}

        /// <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);

        }

   protected Writer(
 File file,
 IOutputStream stream
 )
   {
       this.file = file;
         this.stream = stream;
   }

   public override void WriteTo(
 IOutputStream stream,
 Document context
 )
   {
       stream.Write(BeginChunk);
         base.WriteTo(stream, context);
         stream.Write(EndChunk);
   }

        /// <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 IAsyncAction DownloadAsync(IRecord record, IOutputStream destination)
        {
            if (record == null)
            {
                throw new ArgumentNullException("record");
            }

            return record.DownloadBlob(this, destination);
        }

        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 HashedOutputStream(IOutputStream stream)
        {
            if (stream == null)
                throw new ArgumentNullException("stream");

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

 public RemotePeer(ICommandSerializer serializer, ICommandsTransportResource transport, IOutputStream stream, HostName host, string port)
 {
     _serializer = serializer;
     _transport = transport;
     _dataWriter = new DataWriter(stream);
     HostName = host.RawName;
     Port = port;
     HandleActivity();
     _transport.Received += _transport_Received;
 }

        public SendFile(IOutputStream outputStream,string filename)
        {
            _writer = new DataWriter(outputStream);

            IStorageFolder local = ApplicationData.Current.LocalFolder;
            Task<Stream> taskStream = local.OpenStreamForReadAsync(filename);
            taskStream.Wait();

            Stream s = taskStream.Result;
            _file = new byte[s.Length];
            s.Read(_file, 0, _file.Length);
        }

        /// <summary>
        /// This method supports the framework directly and should not be used from your code
        /// </summary>
        /// <param name="handler">The handler.</param>
        /// <param name="context">The context.</param>
        /// <returns></returns>
        public static void Impl(IOutputStream handler, IContext context)
        {
            context.Response.ContentType = handler.ContentType;
            if (!string.IsNullOrWhiteSpace(handler.ContentDisposition))
            {
                context.Response.SetHeader("Content-Disposition", handler.ContentDisposition);
            }
            if (context.Request.HttpMethod.Equals("HEAD")) return;

            using (var stream = handler.Output)
            {
                stream.Position = 0;
                stream.CopyTo(context.Response.OutputStream);
            }
        }

 private async Task WriteResponseAsync(string request, IOutputStream os)
 {
     // Show the html 
     using (Stream resp = os.AsStreamForWrite())
     {
         using (var file = File.OpenRead(htmlPath))
         {
             string header = $"HTTP/1.1 200 OK\r\nContent-Length: {file.Length}\r\n" +
                              "Content-Type:text/html\r\nConnection: close\r\n\r\n";
             byte[] headerArray = Encoding.UTF8.GetBytes(header);
             await resp.WriteAsync(headerArray, 0, headerArray.Length);
             await file.CopyToAsync(resp);
         }
     }
 }

 public static async Task CopyStreamAsync(this IInputStream src, IOutputStream outStream, uint bufferSize = 16384)
 {
     using (var rd = new DataReader(src))
     {
         using (var wr = new DataWriter(outStream))
         {
             do
             {
                 var r = await rd.LoadAsync(bufferSize);
                 if (r <= 0) break;
                 var buf = new byte[r];
                 rd.ReadBytes(buf);
                 wr.WriteBytes(buf);
                 await wr.FlushAsync();
             } while (true);
         }
     }
 }

        /// <summary>
        /// This method supports the framework directly and should not be used from your code
        /// </summary>
        /// <param name="handler">The handler.</param>
        /// <param name="context">The context.</param>
        /// <returns></returns>
        public static void Impl(IOutputStream handler, IContext context)
        {
            context.Response.SetContentType(handler.ContentType);
            if (!string.IsNullOrWhiteSpace(handler.ContentDisposition))
            {
                context.Response.SetHeader("Content-Disposition", handler.ContentDisposition);
            }
            if (context.Request.HttpMethod.Equals("HEAD")) return;

            context.Response.WriteFunction = (stream, token) =>
                {
                    using (var outputStream = handler.Output)
                    {
                        outputStream.Position = 0;
                        outputStream.CopyTo(stream);
                    }
                    return TaskHelper.Completed();
                };
        }