/// <exception cref="System.IO.IOException"/> public override void close() { if (_out != null) { if (_outPtr > 0) { _out.write(_outBuffer, 0, _outPtr); _outPtr = 0; } Sharpen.OutputStream @out = _out; _out = null; byte[] buf = _outBuffer; if (buf != null) { _outBuffer = null; _context.releaseWriteEncodingBuffer(buf); } @out.close(); /* Let's 'flush' orphan surrogate, no matter what; but only * after cleanly closing everything else. */ int code = _surrogate; _surrogate = 0; if (code > 0) { illegalSurrogate(code); } } }
public static List<DiffEntry> diff_Raw(this API_NGit nGit, OutputStream outputStream) { var diff = nGit.Git.Diff(); if (outputStream.notNull()) diff.SetOutputStream(outputStream); return diff.Call().toList(); }
/// <exception cref="System.IO.IOException"></exception> private static void WriteField(MinimalField field, OutputStream @out) { WriteBytes(field.GetName(), @out); WriteBytes(FieldSep, @out); WriteBytes(field.GetBody(), @out); WriteBytes(CrLf, @out); }
/// <summary>Static method to serialize the metadata object.</summary> /// <remarks> /// Static method to serialize the metadata object. For each serialisation, a new XMPSerializer /// instance is created, either XMPSerializerRDF or XMPSerializerPlain so thats its possible to /// serialialize the same XMPMeta objects in two threads. /// </remarks> /// <param name="xmp">a metadata implementation object</param> /// <param name="out">the output stream to serialize to</param> /// <param name="options">serialization options, can be <code>null</code> for default.</param> /// <exception cref="Com.Adobe.Xmp.XMPException"/> public static void Serialize(XMPMetaImpl xmp, OutputStream @out, SerializeOptions options) { options = options != null ? options : new SerializeOptions(); // sort the internal data model on demand if (options.GetSort()) { xmp.Sort(); } new XMPSerializerRDF().Serialize(xmp, @out, options); }
/// <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(); }
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); } }
public UTF8Writer(com.fasterxml.jackson.core.io.IOContext ctxt, Sharpen.OutputStream @out) { _context = ctxt; _out = @out; _outBuffer = ctxt.allocWriteEncodingBuffer(); /* Max. expansion for a single char (in unmodified UTF-8) is * 4 bytes (or 3 depending on how you view it -- 4 when recombining * surrogate pairs) */ _outBufferEnd = _outBuffer.Length - 4; _outPtr = 0; }
/// <summary> /// Formats the results of a merge of /// <see cref="NGit.Diff.RawText">NGit.Diff.RawText</see> /// objects in a Git /// conformant way. This method also assumes that the /// <see cref="NGit.Diff.RawText">NGit.Diff.RawText</see> /// objects /// being merged are line oriented files which use LF as delimiter. This /// method will also use LF to separate chunks and conflict metadata, /// therefore it fits only to texts that are LF-separated lines. /// </summary> /// <param name="out">the outputstream where to write the textual presentation</param> /// <param name="res">the merge result which should be presented</param> /// <param name="seqName"> /// When a conflict is reported each conflicting range will get a /// name. This name is following the "<<<<<<< " or ">>>>>>> " /// conflict markers. The names for the sequences are given in /// this list /// </param> /// <param name="charsetName"> /// the name of the characterSet used when writing conflict /// metadata /// </param> /// <exception cref="System.IO.IOException">System.IO.IOException</exception> public virtual void FormatMerge(OutputStream @out, MergeResult<RawText> res, IList <string> seqName, string charsetName) { string lastConflictingName = null; // is set to non-null whenever we are // in a conflict bool threeWayMerge = (res.GetSequences().Count == 3); foreach (MergeChunk chunk in res) { RawText seq = res.GetSequences()[chunk.GetSequenceIndex()]; if (lastConflictingName != null && chunk.GetConflictState() != MergeChunk.ConflictState .NEXT_CONFLICTING_RANGE) { // found the end of an conflict @out.Write(Sharpen.Runtime.GetBytesForString((">>>>>>> " + lastConflictingName + "\n"), charsetName)); lastConflictingName = null; } if (chunk.GetConflictState() == MergeChunk.ConflictState.FIRST_CONFLICTING_RANGE) { // found the start of an conflict @out.Write(Sharpen.Runtime.GetBytesForString(("<<<<<<< " + seqName[chunk.GetSequenceIndex ()] + "\n"), charsetName)); lastConflictingName = seqName[chunk.GetSequenceIndex()]; } else { if (chunk.GetConflictState() == MergeChunk.ConflictState.NEXT_CONFLICTING_RANGE) { // found another conflicting chunk lastConflictingName = seqName[chunk.GetSequenceIndex()]; @out.Write(Sharpen.Runtime.GetBytesForString((threeWayMerge ? "=======\n" : "======= " + lastConflictingName + "\n"), charsetName)); } } // the lines with conflict-metadata are written. Now write the chunk for (int i = chunk.GetBegin(); i < chunk.GetEnd(); i++) { seq.WriteLine(@out, i); @out.Write('\n'); } } // one possible leftover: if the merge result ended with a conflict we // have to close the last conflict here if (lastConflictingName != null) { @out.Write(Sharpen.Runtime.GetBytesForString((">>>>>>> " + lastConflictingName + "\n"), charsetName)); } }
/// <summary>Serializes the XmpDirectory component of <code>Metadata</code> into an <code>OutputStream</code></summary> /// <param name="os">Destination for the xmp data</param> /// <param name="data">populated metadata</param> /// <returns>serialize success</returns> public static bool Write(OutputStream os, Com.Drew.Metadata.Metadata data) { XmpDirectory dir = data.GetFirstDirectoryOfType<XmpDirectory>(); if (dir == null) { return false; } XMPMeta meta = dir.GetXMPMeta(); try { SerializeOptions so = new SerializeOptions().SetOmitPacketWrapper(true); XMPMetaFactory.Serialize(meta, os, so); } catch (XMPException e) { Sharpen.Runtime.PrintStackTrace(e); return false; } return true; }
/// <exception cref="System.IO.IOException"></exception> public override void WriteTo(OutputStream @out) { if (@out == null) { throw new ArgumentException("Output stream may not be null"); } try { byte[] tmp = new byte[4096]; int l; while ((l = [email protected](tmp)) != -1) { @out.Write(tmp, 0, l); } @out.Flush(); } finally { [email protected](); } }
/// <param name="out"></param> public AutoCRLFOutputStream(OutputStream @out) { this.@out = @out; }
public FilterOutputStream(OutputStream os) { this.@out = os; }
protected internal PackIndexWriterV2(OutputStream dst) : base(dst) { }
// The hunk header is not taken into account for patch id calculation /// <exception cref="System.IO.IOException"></exception> protected internal override void FormatIndexLine(OutputStream o, DiffEntry ent) { }
/// <summary>Constructor with providing the output stream to decorate.</summary> /// <param name="out">an <code>OutputStream</code></param> internal CountOutputStream(OutputStream @out) { this.@out = @out; }
/// <summary>Execute the receive task on the socket.</summary> /// <remarks>Execute the receive task on the socket.</remarks> /// <param name="input"> /// raw input to read client commands and pack data from. Caller /// must ensure the input is buffered, otherwise read performance /// may suffer. /// </param> /// <param name="output"> /// response back to the Git network client. Caller must ensure /// the output is buffered, otherwise write performance may /// suffer. /// </param> /// <param name="messages"> /// secondary "notice" channel to send additional messages out /// through. When run over SSH this should be tied back to the /// standard error channel of the command execution. For most /// other network connections this should be null. /// </param> /// <exception cref="System.IO.IOException">System.IO.IOException</exception> public virtual void Receive(InputStream input, OutputStream output, OutputStream messages) { Init(input, output, messages); try { Service(); } finally { try { Close(); } finally { Release(); } } }
/// <exception cref="NSch.JSchException"></exception> public virtual void Connect(int connectTimeout) { if (isConnected) { throw new JSchException("session is already connected"); } io = new IO(); if (random == null) { try { Type c = Sharpen.Runtime.GetType(GetConfig("random")); random = (Random)(System.Activator.CreateInstance(c)); } catch (Exception e) { throw new JSchException(e.ToString(), e); } } Packet.SetRandom(random); if (JSch.GetLogger().IsEnabled(Logger.INFO)) { JSch.GetLogger().Log(Logger.INFO, "Connecting to " + host + " port " + port); } try { int i; int j; if (proxy == null) { InputStream @in; OutputStream @out; if (socket_factory == null) { socket = Util.CreateSocket(host, port, connectTimeout); @in = socket.GetInputStream(); @out = socket.GetOutputStream(); } else { socket = socket_factory.CreateSocket(host, port); @in = socket_factory.GetInputStream(socket); @out = socket_factory.GetOutputStream(socket); } //if(timeout>0){ socket.setSoTimeout(timeout); } socket.NoDelay = true; io.SetInputStream(@in); io.SetOutputStream(@out); } else { lock (proxy) { proxy.Connect(socket_factory, host, port, connectTimeout); io.SetInputStream(proxy.GetInputStream()); io.SetOutputStream(proxy.GetOutputStream()); socket = proxy.GetSocket(); } } if (connectTimeout > 0 && socket != null) { socket.ReceiveTimeout = connectTimeout; } isConnected = true; if (JSch.GetLogger().IsEnabled(Logger.INFO)) { JSch.GetLogger().Log(Logger.INFO, "Connection established"); } jsch.AddSession(this); { // Some Cisco devices will miss to read '\n' if it is sent separately. byte[] foo = new byte[V_C.Length + 1]; System.Array.Copy(V_C, 0, foo, 0, V_C.Length); foo[foo.Length - 1] = unchecked((byte)(byte)('\n')); io.Put(foo, 0, foo.Length); } while (true) { i = 0; j = 0; while (i < buf.buffer.Length) { j = io.GetByte(); if (j < 0) { break; } buf.buffer[i] = unchecked((byte)j); i++; if (j == 10) { break; } } if (j < 0) { throw new JSchException("connection is closed by foreign host"); } if (buf.buffer[i - 1] == 10) { // 0x0a i--; if (i > 0 && buf.buffer[i - 1] == 13) { // 0x0d i--; } } if (i <= 3 || ((i != buf.buffer.Length) && (buf.buffer[0] != 'S' || buf.buffer[1] != 'S' || buf.buffer[2] != 'H' || buf.buffer[3] != '-'))) { // It must not start with 'SSH-' //System.err.println(new String(buf.buffer, 0, i); continue; } if (i == buf.buffer.Length || i < 7 || (buf.buffer[4] == '1' && buf.buffer[6] != '9')) { // SSH-1.99 or SSH-2.0 // SSH-1.5 throw new JSchException("invalid server's version string"); } break; } V_S = new byte[i]; System.Array.Copy(buf.buffer, 0, V_S, 0, i); //System.err.println("V_S: ("+i+") ["+new String(V_S)+"]"); if (JSch.GetLogger().IsEnabled(Logger.INFO)) { JSch.GetLogger().Log(Logger.INFO, "Remote version string: " + Util.Byte2str(V_S)); JSch.GetLogger().Log(Logger.INFO, "Local version string: " + Util.Byte2str(V_C)); } Send_kexinit(); buf = Read(buf); if (buf.GetCommand() != SSH_MSG_KEXINIT) { in_kex = false; throw new JSchException("invalid protocol: " + buf.GetCommand()); } if (JSch.GetLogger().IsEnabled(Logger.INFO)) { JSch.GetLogger().Log(Logger.INFO, "SSH_MSG_KEXINIT received"); } KeyExchange kex = Receive_kexinit(buf); while (true) { buf = Read(buf); if (kex.GetState() == buf.GetCommand()) { kex_start_time = Runtime.CurrentTimeMillis(); bool result = kex.Next(buf); if (!result) { //System.err.println("verify: "+result); in_kex = false; throw new JSchException("verify: " + result); } } else { in_kex = false; throw new JSchException("invalid protocol(kex): " + buf.GetCommand()); } if (kex.GetState() == KeyExchange.STATE_END) { break; } } try { CheckHost(host, port, kex); } catch (JSchException ee) { in_kex = false; throw; } Send_newkeys(); // receive SSH_MSG_NEWKEYS(21) buf = Read(buf); //System.err.println("read: 21 ? "+buf.getCommand()); if (buf.GetCommand() == SSH_MSG_NEWKEYS) { if (JSch.GetLogger().IsEnabled(Logger.INFO)) { JSch.GetLogger().Log(Logger.INFO, "SSH_MSG_NEWKEYS received"); } Receive_newkeys(buf, kex); } else { in_kex = false; throw new JSchException("invalid protocol(newkyes): " + buf.GetCommand()); } bool auth = false; bool auth_cancel = false; UserAuth ua = null; try { Type c = Sharpen.Runtime.GetType(GetConfig("userauth.none")); ua = (UserAuth)(System.Activator.CreateInstance(c)); } catch (Exception e) { throw new JSchException(e.ToString(), e); } auth = ua.Start(this); string cmethods = GetConfig("PreferredAuthentications"); string[] cmethoda = Util.Split(cmethods, ","); string smethods = null; if (!auth) { smethods = ((UserAuthNone)ua).GetMethods(); if (smethods != null) { smethods = smethods.ToLower(); } else { // methods: publickey,password,keyboard-interactive //smethods="publickey,password,keyboard-interactive"; smethods = cmethods; } } string[] smethoda = Util.Split(smethods, ","); int methodi = 0; while (true) { //System.err.println("methods: "+methods); while (!auth && cmethoda != null && methodi < cmethoda.Length) { string method = cmethoda[methodi++]; bool acceptable = false; for (int k = 0; k < smethoda.Length; k++) { if (smethoda[k].Equals(method)) { acceptable = true; break; } } if (!acceptable) { continue; } //System.err.println(" method: "+method); if (JSch.GetLogger().IsEnabled(Logger.INFO)) { string str = "Authentications that can continue: "; for (int k_1 = methodi - 1; k_1 < cmethoda.Length; k_1++) { str += cmethoda[k_1]; if (k_1 + 1 < cmethoda.Length) { str += ","; } } JSch.GetLogger().Log(Logger.INFO, str); JSch.GetLogger().Log(Logger.INFO, "Next authentication method: " + method); } ua = null; try { Type c = null; if (GetConfig("userauth." + method) != null) { c = Sharpen.Runtime.GetType(GetConfig("userauth." + method)); ua = (UserAuth)(System.Activator.CreateInstance(c)); } } catch (Exception) { if (JSch.GetLogger().IsEnabled(Logger.WARN)) { JSch.GetLogger().Log(Logger.WARN, "failed to load " + method + " method"); } } if (ua != null) { auth_cancel = false; try { auth = ua.Start(this); if (auth && JSch.GetLogger().IsEnabled(Logger.INFO)) { JSch.GetLogger().Log(Logger.INFO, "Authentication succeeded (" + method + ")."); } } catch (JSchAuthCancelException) { auth_cancel = true; } catch (JSchPartialAuthException ee) { string tmp = smethods; smethods = ee.GetMethods(); smethoda = Util.Split(smethods, ","); if (!tmp.Equals(smethods)) { methodi = 0; } //System.err.println("PartialAuth: "+methods); auth_cancel = false; goto loop_continue; } catch (RuntimeException ee) { throw; } catch (Exception) { //System.err.println("ee: "+ee); // SSH_MSG_DISCONNECT: 2 Too many authentication failures goto loop_break; } } } break; loop_continue: ; } loop_break: ; if (!auth) { if (auth_cancel) { throw new JSchException("Auth cancel"); } throw new JSchException("Auth fail"); } if (connectTimeout > 0 || timeout > 0) { socket.ReceiveTimeout = timeout; } isAuthed = true; lock (Lock) { if (isConnected) { connectThread = new Sharpen.Thread(this); connectThread.SetName("Connect thread " + host + " session"); if (daemon_thread) { connectThread.SetDaemon(daemon_thread); } connectThread.Start(); } } } catch (Exception e) { // The session has been already down and // we don't have to start new thread. in_kex = false; if (isConnected) { try { packet.Reset(); buf.PutByte(unchecked((byte)SSH_MSG_DISCONNECT)); buf.PutInt(3); buf.PutString(Util.Str2byte(e.ToString())); buf.PutString(Util.Str2byte("en")); Write(packet); Disconnect(); } catch (Exception) { } } isConnected = false; //e.printStackTrace(); if (e is RuntimeException) { throw (RuntimeException)e; } if (e is JSchException) { throw (JSchException)e; } throw new JSchException("Session.connect: " + e); } finally { Util.Bzero(this.password); this.password = null; } }
public OutputStreamWriter(OutputStream stream, Encoding encoding) : base(stream.GetWrappedStream(), encoding) { }
public override void Close() { if (@out != null) { try { if (outNeedsEnd) { outNeedsEnd = false; pckOut.End(); } @out.Close(); } catch (IOException) { } finally { // Ignore any close errors. @out = null; pckOut = null; } } if (@in != null) { try { @in.Close(); } catch (IOException) { } finally { // Ignore any close errors. @in = null; pckIn = null; } } if (myTimer != null) { try { myTimer.Terminate(); } finally { myTimer = null; timeoutIn = null; timeoutOut = null; } } }
public static OutputStream GetOutputStream(this Process p) { return(OutputStream.Wrap(p.StandardInput.BaseStream)); }
public OutputStreamWriter(OutputStream stream) : base(stream.GetWrappedStream()) { }
public ObjectOutputStream(OutputStream os) { this.bw = new BinaryWriter(os.GetWrappedStream()); }
public BufferedOutputStream(OutputStream outs, int bufferSize) { base.Wrapped = new BufferedStream(outs.GetWrappedStream(), bufferSize); }
public BufferedOutputStream(OutputStream outs) { base.Wrapped = new BufferedStream(outs == null ? new MemoryStream() : outs.GetWrappedStream()); }
public BufferedOutputStream(OutputStream outs, int bufferSize) { base.Wrapped = new BufferedStream (outs.GetWrappedStream (), bufferSize); }
public WrappedSystemStream(OutputStream ost) { this.ost = ost; }
public BufferedOutputStream(OutputStream outs) { base.Wrapped = new BufferedStream (outs.GetWrappedStream ()); }
public OutputStreamWriter(OutputStream stream, string encoding) : base(stream.GetWrappedStream(), Extensions.GetEncoding(encoding)) { }
public virtual void SetOutputStream(OutputStream @out) { this.@out = @out; }
/// <summary>Execute the upload task on the socket.</summary> /// <remarks>Execute the upload task on the socket.</remarks> /// <param name="input"> /// raw input to read client commands from. Caller must ensure the /// input is buffered, otherwise read performance may suffer. /// </param> /// <param name="output"> /// response back to the Git network client, to write the pack /// data onto. Caller must ensure the output is buffered, /// otherwise write performance may suffer. /// </param> /// <param name="messages"> /// secondary "notice" channel to send additional messages out /// through. When run over SSH this should be tied back to the /// standard error channel of the command execution. For most /// other network connections this should be null. /// </param> /// <exception cref="System.IO.IOException">System.IO.IOException</exception> public virtual void Upload(InputStream input, OutputStream output, OutputStream messages ) { try { rawIn = input; rawOut = output; if (timeout > 0) { Sharpen.Thread caller = Sharpen.Thread.CurrentThread(); timer = new InterruptTimer(caller.GetName() + "-Timer"); TimeoutInputStream i = new TimeoutInputStream(rawIn, timer); TimeoutOutputStream o = new TimeoutOutputStream(rawOut, timer); i.SetTimeout(timeout * 1000); o.SetTimeout(timeout * 1000); rawIn = i; rawOut = o; } pckIn = new PacketLineIn(rawIn); pckOut = new PacketLineOut(rawOut); Service(); } finally { walk.Release(); if (timer != null) { try { timer.Terminate(); } finally { timer = null; } } } }
public _OutputStream_323(LockFile _enclosing, OutputStream @out) { this._enclosing = _enclosing; this.@out = @out; }
/// <summary>Create a new stream to write side band packets.</summary> /// <remarks>Create a new stream to write side band packets.</remarks> /// <param name="chan"> /// channel number to prefix all packets with, so the remote side /// can demultiplex the stream and get back the original data. /// Must be in the range [0, 255]. /// </param> /// <param name="sz"> /// maximum size of a data packet within the stream. The remote /// side needs to agree to the packet size to prevent buffer /// overflows. Must be in the range [HDR_SIZE + 1, MAX_BUF). /// </param> /// <param name="os"> /// stream that the packets are written onto. This stream should /// be attached to a SideBandInputStream on the remote side. /// </param> public SideBandOutputStream(int chan, int sz, OutputStream os) { if (chan <= 0 || chan > 255) { throw new ArgumentException(MessageFormat.Format(JGitText.Get().channelMustBeInRange0_255 , chan)); } if (sz <= HDR_SIZE) { throw new ArgumentException(MessageFormat.Format(JGitText.Get().packetSizeMustBeAtLeast , sz, HDR_SIZE)); } else { if (MAX_BUF < sz) { throw new ArgumentException(MessageFormat.Format(JGitText.Get().packetSizeMustBeAtMost , sz, MAX_BUF)); } } @out = os; buffer = new byte[sz]; buffer[4] = unchecked((byte)chan); cnt = HDR_SIZE; }
/// <summary>Write a specific line to the output stream, without its trailing LF.</summary> /// <remarks> /// Write a specific line to the output stream, without its trailing LF. /// <p> /// The specified line is copied as-is, with no character encoding /// translation performed. /// <p> /// If the specified line ends with an LF ('\n'), the LF is <b>not</b> /// copied. It is up to the caller to write the LF, if desired, between /// output lines. /// </remarks> /// <param name="out">stream to copy the line data onto.</param> /// <param name="i"> /// index of the line to extract. Note this is 0-based, so line /// number 1 is actually index 0. /// </param> /// <exception cref="System.IO.IOException">the stream write operation failed.</exception> public virtual void WriteLine(OutputStream @out, int i) { int start = GetStart(i); int end = GetEnd(i); if (content[end - 1] == '\n') { end--; } @out.Write(content, start, end - start); }
public override void SetOutputStream(OutputStream @out) { io.SetOutputStream(@out); }
/// <summary>Configure this connection with the directional pipes.</summary> /// <remarks>Configure this connection with the directional pipes.</remarks> /// <param name="myIn"> /// input stream to receive data from the peer. Caller must ensure /// the input is buffered, otherwise read performance may suffer. /// </param> /// <param name="myOut"> /// output stream to transmit data to the peer. Caller must ensure /// the output is buffered, otherwise write performance may /// suffer. /// </param> protected internal void Init(InputStream myIn, OutputStream myOut) { int timeout = transport.GetTimeout(); if (timeout > 0) { Sharpen.Thread caller = Sharpen.Thread.CurrentThread(); myTimer = new InterruptTimer(caller.GetName() + "-Timer"); timeoutIn = new TimeoutInputStream(myIn, myTimer); timeoutOut = new TimeoutOutputStream(myOut, myTimer); timeoutIn.SetTimeout(timeout * 1000); timeoutOut.SetTimeout(timeout * 1000); myIn = timeoutIn; myOut = timeoutOut; } @in = myIn; @out = myOut; pckIn = new PacketLineIn(@in); pckOut = new PacketLineOut(@out); outNeedsEnd = true; }
/// <summary>Tell the peer we are disconnecting, if it cares to know.</summary> /// <remarks>Tell the peer we are disconnecting, if it cares to know.</remarks> protected internal virtual void EndOut() { if (outNeedsEnd && @out != null) { try { outNeedsEnd = false; pckOut.End(); } catch (IOException) { try { @out.Close(); } catch (IOException) { } finally { // Ignore any close errors. @out = null; pckOut = null; } } } }
/// <exception cref="System.IO.IOException"></exception> internal virtual void ExtractFileLines(OutputStream[] @out) { byte[] buf = file.buf; int ptr = startOffset; int eol = RawParseUtils.NextLF(buf, ptr); if (endOffset <= eol) { return; } // Treat the hunk header as though it were from the ancestor, // as it may have a function header appearing after it which // was copied out of the ancestor file. // @out[0].Write(buf, ptr, eol - ptr); for (ptr = eol; ptr < endOffset; ptr = eol) { eol = RawParseUtils.NextLF(buf, ptr); switch (buf[ptr]) { case (byte)(' '): case (byte)('\n'): case (byte)('\\'): { @out[0].Write(buf, ptr, eol - ptr); @out[1].Write(buf, ptr, eol - ptr); break; } case (byte)('-'): { @out[0].Write(buf, ptr, eol - ptr); break; } case (byte)('+'): { @out[1].Write(buf, ptr, eol - ptr); break; } default: { goto SCAN_break; break; } } SCAN_continue: ; } SCAN_break: ; }
/// <summary>Generate and write the bundle to the output stream.</summary> /// <remarks> /// Generate and write the bundle to the output stream. /// <p> /// This method can only be called once per BundleWriter instance. /// </remarks> /// <param name="monitor">progress monitor to report bundle writing status to.</param> /// <param name="os"> /// the stream the bundle is written to. The stream should be /// buffered by the caller. The caller is responsible for closing /// the stream. /// </param> /// <exception cref="System.IO.IOException"> /// an error occurred reading a local object's data to include in /// the bundle, or writing compressed object data to the output /// stream. /// </exception> public virtual void WriteBundle(ProgressMonitor monitor, OutputStream os) { PackConfig pc = packConfig; if (pc == null) { pc = new PackConfig(db); } PackWriter packWriter = new PackWriter(pc, db.NewObjectReader()); try { HashSet<ObjectId> inc = new HashSet<ObjectId>(); HashSet<ObjectId> exc = new HashSet<ObjectId>(); Sharpen.Collections.AddAll(inc, include.Values); foreach (RevCommit r in assume) { exc.AddItem(r.Id); } packWriter.SetDeltaBaseAsOffset(true); packWriter.SetThin(exc.Count > 0); packWriter.SetReuseValidatingObjects(false); if (exc.Count == 0) { packWriter.SetTagTargets(tagTargets); } packWriter.PreparePack(monitor, inc, exc); TextWriter w = new OutputStreamWriter(os, Constants.CHARSET); w.Write(NGit.Transport.TransportBundleConstants.V2_BUNDLE_SIGNATURE); w.Write('\n'); char[] tmp = new char[Constants.OBJECT_ID_STRING_LENGTH]; foreach (RevCommit a in assume) { w.Write('-'); a.CopyTo(tmp, w); if (a.RawBuffer != null) { w.Write(' '); w.Write(a.GetShortMessage()); } w.Write('\n'); } foreach (KeyValuePair<string, ObjectId> e in include.EntrySet()) { e.Value.CopyTo(tmp, w); w.Write(' '); w.Write(e.Key); w.Write('\n'); } w.Write('\n'); w.Flush(); packWriter.WritePack(monitor, monitor, os); } finally { packWriter.Release(); } }
public GZIPOutputStream(OutputStream os) { Wrapped = new GZipStream(os, CompressionMode.Compress); }