C:/work/OMMR/OCHHP_OMMR_OMMR/Code/Assemblies/SharpSSH/Source/SharpSSH-1.1.1.13.src/SharpSSH/Streams/PipedOutputStream.cs

Go to the documentation of this file.

using System;
using System.IO;
using System.Runtime.CompilerServices;

namespace Tamir.Streams
{
        /*
         * @(#)PipedOutputStream.java   1.26 03/12/19
         *
         * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
         * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
         */

        public class PipedOutputStream : Tamir.SharpSsh.java.io.OutputStream
        {

                /* REMIND: identification of the read and write sides needs to be
                        more sophisticated.  Either using thread groups (but what about
                        pipes within a thread?) or using finalization (but it may be a
                        long time until the next GC). */
                private PipedInputStream sink;

                public PipedOutputStream(PipedInputStream snk)
                {
                        connect(snk);
                }
    
                public PipedOutputStream() 
                {
                }
    
                [MethodImpl(MethodImplOptions.Synchronized)]
                public virtual void connect(PipedInputStream snk)
                {
                        if (snk == null) 
                        {
                                throw new NullReferenceException();
                        } 
                        else if (sink != null || snk.connected) 
                        {
                                throw new IOException("Already connected");
                        }
                        sink = snk;
                        snk.m_in = -1;
                        snk.m_out = 0;
                        snk.connected = true;
                        int t=0;
                }

                public virtual void write(int b)
                {
                        if (sink == null) 
                        {
                                throw new IOException("Pipe not connected");
                        }
                        sink.receive(b);
                }

                public override void write(byte[] b, int off, int len)
                {
                        if (sink == null) 
                        {
                                throw new IOException("Pipe not connected");
                        } 
                        else if (b == null) 
                        {
                                throw new NullReferenceException();
                        } 
                        else if ((off < 0) || (off > b.Length) || (len < 0) ||
                                ((off + len) > b.Length) || ((off + len) < 0)) 
                        {
                                throw new IndexOutOfRangeException();
                        } 
                        else if (len == 0) 
                        {
                                return;
                        } 
                        sink.receive(b, off, len);
                }

                public virtual void write(byte[] b)
                {
                        write(b, 0, b.Length);
                }

                [MethodImpl(MethodImplOptions.Synchronized)]
                public override void flush()
                {
                        if (sink != null) 
                        {
                                lock (sink) 
                                {
                                        //sink.notifyAll();
                                        System.Threading.Monitor.PulseAll(sink);
                                }
                        }
                }

                public override void close() 
                {
                        if (sink != null) 
                        {
                                sink.receivedLast();
                        }
                }

                

                public override int Read(byte[] buffer, int offset, int count)
                {
                        return 0;
                }

                public override int ReadByte()
                {
                        return 0;
                }
                
                public override void WriteByte(byte value)
                {
                        this.write(value);
                }

                public override void Write(byte[] buffer, int offset, int count)
                {
                        this.write(buffer, offset, count);
                }
                public virtual void Write(byte[] buffer)
                {
                        this.Write(buffer, 0, buffer.Length);
                }
                public override void Close()
                {
                        base.Close ();
                        this.close();
                }
                public override bool CanRead
                {
                        get
                        {
                                return false;
                        }
                }
                public override bool CanWrite
                {
                        get
                        {
                                return true;
                        }
                }
                public override bool CanSeek
                {
                        get
                        {
                                return false;
                        }
                }
                public override void Flush()
                {
                        this.flush();
                }
                public override long Length
                {
                        get
                        {
                                return sink.Length;
                        }
                }
                public override long Position
                {
                        get
                        {
                                return sink.m_in;
                        }
                        set
                        {
                                throw new IOException("Setting the position of this stream is not supported");
                        }
                }
                public override void SetLength(long value)
                {
                        throw new IOException("Setting the length of this stream is not supported");
                }
                public override long Seek(long offset, SeekOrigin origin)
                {
                        return 0;
                }
        }

}

---