C# zmq.Pipe类代码示例

        protected override void XAttachPipe(Pipe pipe, bool icanhasall)
        {
            Debug.Assert(pipe != null);

            //  ZMQ_PAIR socket can only be connected to a single peer.
            //  The socket rejects any further connection requests.
            if (m_pipe == null)
                m_pipe = pipe;
            else
                pipe.Terminate (false);
        }

        //  Activates pipe that have previously reached high watermark.
        public void Activated(Pipe pipe)
        {
            //  Move the pipe from passive to eligible state.
            Utils.Swap (m_pipes, m_pipes.IndexOf (pipe), m_eligible);
            m_eligible++;

            //  If there's no message being sent at the moment, move it to
            //  the active state.
            if (!m_more) {
                Utils.Swap (m_pipes, m_eligible - 1, m_active);
                m_active++;
            }
        }

 //  Removes the pipe from the distributor object.
 public void Terminated(Pipe pipe)
 {
     //  Remove the pipe from the list; adjust number of matching, active and/or
     //  eligible pipes accordingly.
     if (m_pipes.IndexOf (pipe) < m_matching)
         m_matching--;
     if (m_pipes.IndexOf (pipe) < m_active)
         m_active--;
     if (m_pipes.IndexOf (pipe) < m_eligible)
         m_eligible--;
     m_pipes.Remove(pipe);
 }

 protected void SendPipeTermAck(Pipe destination)
 {
     Command cmd = new Command(destination, CommandType.PipeTermAck);
     SendCommand (cmd);
 }

        protected void SendBind(Own destination, Pipe pipe,
		                          bool incSeqnum)
        {
            if (incSeqnum)
                destination.IncSeqnum ();

            Command cmd = new Command(destination, CommandType.Bind, pipe);
            SendCommand (cmd);
        }

        protected void SendActivateWrite(Pipe destination,
		                                    long msgsRead)
        {
            Command cmd = new Command(destination, CommandType.ActivateWrite, msgsRead);
            SendCommand (cmd);
        }

 protected virtual void ProcessBind(Pipe pipe)
 {
     throw new NotSupportedException();
 }

        protected override void XTerminated(Pipe pipe)
        {
            //  Remove the pipe from the trie. If there are topics that nobody
            //  is interested in anymore, send corresponding unsubscriptions
            //  upstream.

            m_subscriptions.RemoveHelper(pipe, s_SendUnsubscription, this);

            m_dist.Terminated(pipe);
        }

        public void Terminated(Pipe pipe)
        {
            //  Drop the reference to the deallocated pipe.
            Debug.Assert(m_pipe == pipe || m_terminatingPipes.Contains(pipe));

            if (m_pipe == pipe)
                // If this is our current pipe, remove it
                m_pipe = null;
            else
                // Remove the pipe from the detached pipes set
                m_terminatingPipes.Remove(pipe);

            if (!IsTerminating && m_options.RawSocket)
            {
                if (m_engine != null)
                {
                    m_engine.Terminate();
                    m_engine = null;
                }
                Terminate();
            }

            //  If we are waiting for pending messages to be sent, at this point
            //  we are sure that there will be no more messages and we can proceed
            //  with termination safely.
            if (m_pending && m_pipe == null && m_terminatingPipes.Count == 0)
                ProceedWithTerm();
        }

        public void ReadActivated(Pipe pipe)
        {
            // Skip activating if we're detaching this pipe
            if (m_pipe != pipe)
            {
                Debug.Assert(m_terminatingPipes.Contains(pipe));
                return;
            }

            if (m_engine != null)
                m_engine.ActivateOut();
            else
                m_pipe.CheckRead();
        }

 public void Hiccuped(Pipe pipe)
 {
     //  Hiccups are always sent from session to socket, not the other
     //  way round.
     throw new NotSupportedException("Must Override");
 }

 //  To be used once only, when creating the session.
 public void AttachPipe(Pipe pipe)
 {
     Debug.Assert(!IsTerminating);
     Debug.Assert(m_pipe == null);
     Debug.Assert(pipe != null);
     m_pipe = pipe;
     m_pipe.SetEventSink(this);
 }

 //  Adds the pipe to the distributor object.
 public void Attach(Pipe pipe)
 {
     //  If we are in the middle of sending a message, we'll add new pipe
     //  into the list of eligible pipes. Otherwise we add it to the list
     //  of active pipes.
     if (m_more) {
         m_pipes.Add (pipe);
         //pipes.swap (eligible, pipes.size () - 1);
         Utils.Swap(m_pipes, m_eligible, m_pipes.Count - 1);
         m_eligible++;
     }
     else {
         m_pipes.Add (pipe);
         //pipes.swap (active, pipes.size () - 1);
         Utils.Swap(m_pipes, m_active, m_pipes.Count - 1);
         m_active++;
         m_eligible++;
     }
 }

 //  Write the message to the pipe. Make the pipe inactive if writing
 //  fails. In such a case false is returned.
 private bool Write(Pipe pipe, Msg msg)
 {
     if (!pipe.Write (msg)) {
         Utils.Swap(m_pipes, m_pipes.IndexOf (pipe), m_matching - 1);
         m_matching--;
         Utils.Swap(m_pipes, m_pipes.IndexOf (pipe), m_active - 1);
         m_active--;
         Utils.Swap(m_pipes, m_active, m_eligible - 1);
         m_eligible--;
         return false;
     }
     if (!msg.HasMore)
         pipe.Flush ();
     return true;
 }

        protected override void XAttachPipe(Pipe pipe, bool icanhasall)
        {
            Debug.Assert(pipe != null);
            m_dist.Attach(pipe);

            //  If icanhasall_ is specified, the caller would like to subscribe
            //  to all data on this pipe, implicitly.
            if (icanhasall)
                m_subscriptions.Add(null, pipe);

            //  The pipe is active when attached. Let's read the subscriptions from
            //  it, if any.
            XReadActivated(pipe);
        }