/// <exception cref="NGit.Errors.CorruptObjectException"></exception>
		/// <exception cref="System.IO.IOException"></exception>
		internal PackIndexV1(InputStream fd, byte[] hdr)
		{
			byte[] fanoutTable = new byte[IDX_HDR_LEN];
			System.Array.Copy(hdr, 0, fanoutTable, 0, hdr.Length);
			IOUtil.ReadFully(fd, fanoutTable, hdr.Length, IDX_HDR_LEN - hdr.Length);
			idxHeader = new long[256];
			// really unsigned 32-bit...
			for (int k = 0; k < idxHeader.Length; k++)
			{
				idxHeader[k] = NB.DecodeUInt32(fanoutTable, k * 4);
			}
			idxdata = new byte[idxHeader.Length][];
			for (int k_1 = 0; k_1 < idxHeader.Length; k_1++)
			{
				int n;
				if (k_1 == 0)
				{
					n = (int)(idxHeader[k_1]);
				}
				else
				{
					n = (int)(idxHeader[k_1] - idxHeader[k_1 - 1]);
				}
				if (n > 0)
				{
					idxdata[k_1] = new byte[n * (Constants.OBJECT_ID_LENGTH + 4)];
					IOUtil.ReadFully(fd, idxdata[k_1], 0, idxdata[k_1].Length);
				}
			}
			objectCnt = idxHeader[255];
			packChecksum = new byte[20];
			IOUtil.ReadFully(fd, packChecksum, 0, packChecksum.Length);
		}

		internal Attachment(InputStream contentStream, string contentType)
		{
			this.body = contentStream;
			metadata = new Dictionary<string, object>();
			metadata.Put("content_type", contentType);
			metadata.Put("follows", true);
			this.gzipped = false;
		}

		public StreamReader(InputStream stream)
		{
			if (stream == null)
			{
				throw new ArgumentNullException();
			}
			_stream = stream;
		}

 public MergedStream(com.fasterxml.jackson.core.io.IOContext ctxt, Sharpen.InputStream
     @in, byte[] buf, int start, int end)
 {
     _ctxt = ctxt;
     _in = @in;
     _b = buf;
     _ptr = start;
     _end = end;
 }

		public static Com.Drew.Metadata.Metadata ReadMetadata(InputStream inputStream)
		{
			// TIFF processing requires random access, as directories can be scattered throughout the byte sequence.
			// InputStream does not support seeking backwards, and so is not a viable option for TIFF processing.
			// We use RandomAccessStreamReader, which buffers data from the stream as we seek forward.
			Com.Drew.Metadata.Metadata metadata = new Com.Drew.Metadata.Metadata();
			new ExifReader().ExtractTiff(new RandomAccessStreamReader(inputStream), metadata);
			return metadata;
		}

		public ZInputStream(InputStream @in, int level) : base(@in)
		{
			[email protected] = @in;
			z.DeflateInit(level);
			compress = true;
			z.next_in = buf;
			z.next_in_index = 0;
			z.avail_in = 0;
		}

 /*
 /**********************************************************
 /* Public API
 /**********************************************************
 */
 /// <exception cref="System.IO.IOException"/>
 public override void close()
 {
     Sharpen.InputStream @in = _in;
     if (@in != null)
     {
         _in = null;
         freeBuffers();
         @in.close();
     }
 }

 public InputStreamBody(InputStream @in, string mimeType, string filename) : base(
     mimeType)
 {
     if (@in == null)
     {
         throw new ArgumentException("Input stream may not be null");
     }
     [email protected] = @in;
     this.filename = filename;
 }

 protected internal DataFormatMatcher(Sharpen.InputStream @in, byte[] buffered, int
     bufferedStart, int bufferedLength, com.fasterxml.jackson.core.JsonFactory match
     , com.fasterxml.jackson.core.format.MatchStrength strength)
 {
     _originalStream = @in;
     _bufferedData = buffered;
     _bufferedStart = bufferedStart;
     _bufferedLength = bufferedLength;
     _match = match;
     _matchStrength = strength;
 }

 /// <exception cref="System.IO.IOException"></exception>
 public static void CopyStream(InputStream @is, OutputStream os)
 {
     int n;
     byte[] buffer = new byte[16384];
     while ((n = @is.Read(buffer)) > -1)
     {
         os.Write(buffer, 0, n);
     }
     os.Close();
     @is.Close();
 }

 /// <exception cref="System.IO.IOException"></exception>
 public static void CopyStreamToFile(InputStream @is, FilePath file)
 {
     OutputStream os = new FileOutputStream(file);
     int n;
     byte[] buffer = new byte[16384];
     while ((n = @is.Read(buffer)) > -1)
     {
         os.Write(buffer, 0, n);
     }
     os.Close();
     @is.Close();
 }

		public URLConnection(Uri url) : base(url)
		{
			responseInputStream = new PipedInputStream();
			try
			{
				responseOutputStream = new PipedOutputStream((PipedInputStream)responseInputStream
					);
			}
			catch (IOException e)
			{
				Log.E(Database.Tag, "Exception creating piped output stream", e);
			}
		}

 /// <summary>
 /// Constructor used when content to check is available via
 /// input stream and must be read.
 /// </summary>
 public Std(Sharpen.InputStream @in, byte[] buffer)
 {
     /*
     /**********************************************************
     /* Standard implementation
     /**********************************************************
     */
     _in = @in;
     _buffer = buffer;
     _bufferedStart = 0;
     _ptr = 0;
     _bufferedEnd = 0;
 }

		/// <exception cref="System.IO.IOException"></exception>
		public static byte[] Read(InputStream @is)
		{
			int initialCapacity = 1024;
			ByteArrayBuffer byteArrayBuffer = new ByteArrayBuffer(initialCapacity);
			byte[] bytes = new byte[512];
			int offset = 0;
			int numRead = 0;
			while ((numRead = @is.Read(bytes, offset, bytes.Length - offset)) >= 0)
			{
				byteArrayBuffer.Append(bytes, 0, numRead);
				offset += numRead;
			}
			return byteArrayBuffer.ToByteArray();
		}

 public UTF32Reader(com.fasterxml.jackson.core.io.IOContext ctxt, Sharpen.InputStream
     @in, byte[] buf, int ptr, int len, bool isBigEndian)
 {
     /*
     /**********************************************************
     /* Life-cycle
     /**********************************************************
     */
     _context = ctxt;
     _in = @in;
     _buffer = buf;
     _ptr = ptr;
     _length = len;
     _bigEndian = isBigEndian;
     _managedBuffers = (@in != null);
 }

 /// <summary>Loads the stream into a buffer.</summary>
 /// <param name="in">an InputStream</param>
 /// <exception cref="System.IO.IOException">If the stream cannot be read.</exception>
 public ByteBuffer(InputStream @in)
 {
     // load stream into buffer
     int chunk = 16384;
     this.length = 0;
     this.buffer = new sbyte[chunk];
     int read;
     while ((read = @in.Read(this.buffer, this.length, chunk)) > 0)
     {
         this.length += read;
         if (read == chunk)
         {
             EnsureCapacity(length + chunk);
         }
         else
         {
             break;
         }
     }
 }

        public static void Load(this Hashtable props, InputStream stream)
        {
            using (var reader = new InputStreamReader(stream, Encoding.UTF8))
            {
                while (!reader.EndOfStream)
                {
                    var line = reader.ReadLine();
                    if (!String.IsNullOrWhiteSpace(line) && !line.StartsWith("#"))
                    {
                        var parts = line.Split('=');
                        if (parts.Length != 2)
                            throw new InvalidOperationException("Properties must be key value pairs separated by an '='.");

                        if (!props.ContainsKey(parts[0]))
                            props.Add(parts[0], parts[1]);
                        else
                            props[parts[0]] = parts[1];
                    }
                }
            }
        }

		/// <exception cref="NGit.Errors.TransportException"></exception>
		internal BundleFetchConnection(NGit.Transport.Transport transportBundle, InputStream
			 src)
		{
			transport = transportBundle;
			bin = new BufferedInputStream(src);
			try
			{
				switch (ReadSignature())
				{
					case 2:
					{
						ReadBundleV2();
						break;
					}

					default:
					{
						throw new TransportException(transport.uri, JGitText.Get().notABundle);
					}
				}
			}
			catch (TransportException err)
			{
				Close();
				throw;
			}
			catch (IOException err)
			{
				Close();
				throw new TransportException(transport.uri, err.Message, err);
			}
			catch (RuntimeException err)
			{
				Close();
				throw new TransportException(transport.uri, err.Message, err);
			}
		}

        /// <exception cref="EU.Europa.EC.Markt.Dss.CannotFetchDataException"></exception>
        public Stream Post(string URL, InputStream content)
        {
            try
            {
                LOG.Info("Post data to url " + URL);      

                byte[] data = Streams.ReadAll(content);

                HttpWebRequest request = (HttpWebRequest)WebRequest.Create(URL);
                request.Timeout = TimeOut;
                request.Method = "POST";
                request.ContentLength = data.Length;

                if (ContentType != null)
                {
                    request.ContentType = ContentType;
                }

                if (Accept != null)
                {
                    request.Accept = Accept;
                }

                Stream dataStream = request.GetRequestStream();
                dataStream.Write(data, 0, data.Length);
                dataStream.Close();

                HttpWebResponse response = (HttpWebResponse)request.GetResponse();
                dataStream = response.GetResponseStream();

                return dataStream;
            }
            catch (IOException ex)
            {
                throw new CannotFetchDataException(ex, URL);
            }
        }

		/// <exception cref="System.IO.IOException"></exception>
		public override ObjectId Insert(int type, long len, InputStream @is)
		{
			MessageDigest md = Digest();
			FilePath tmp = ToTemp(md, type, len, @is);
			ObjectId id = ObjectId.FromRaw(md.Digest());
			switch (db.InsertUnpackedObject(tmp, id, false))
			{
				case FileObjectDatabase.InsertLooseObjectResult.INSERTED:
				case FileObjectDatabase.InsertLooseObjectResult.EXISTS_PACKED:
				case FileObjectDatabase.InsertLooseObjectResult.EXISTS_LOOSE:
				{
					return id;
				}

				case FileObjectDatabase.InsertLooseObjectResult.FAILURE:
				default:
				{
					break;
					break;
				}
			}
			FilePath dst = db.FileFor(id);
			throw new ObjectWritingException("Unable to create new object: " + dst);
		}