// package constructor: called by OtpNode:createMbox(name)
		// to create a named mbox
		internal OtpMbox(OtpNode home, Erlang.Pid self, System.String name)
		{
			this._self = self;
			this.home = home;
			this.name = name;
			this.queue = new GenericQueue();
			this.links = new Links(10);
            this.monitors = new System.Collections.Hashtable(49, (float)0.95);
		}

 // send has receiver pid but no sender information
 internal OtpMsg(Erlang.Pid to, OtpInputStream paybuf)
 {
     this.tag = sendTag;
     this.from = null;
     this.to = to;
     this.toName = null;
     this.paybuf = paybuf;
     this.payload = null;
 }

 public override bool subst(ref Erlang.Object obj, Erlang.VarBind binding)
 {
     if (isAny() || binding == null || binding.Empty)
         throw new UnboundVarException();
     Erlang.Object term = binding[m_var];
     if (term == null)
         throw new UnboundVarException("Variable " + m_var + " not bound!");
     obj = term;
     return true;
 }

        /*
        * Create a stream containing the serialized Erlang term.
        * Optionally include in the beginning Erlang protocol version byte.
        **/
        public OtpOutputStream(Erlang.Object o, bool writeVersion, bool writePktSize)
            : this()
        {
            if (!writePktSize)
            {
                encodeObject(o, writeVersion);
                return;
            }

            write4BE(0); // make space for length data,
                         // but final value is not yet known
            encodeObject(o, writeVersion);
            poke4BE(0, this._count - 4);
        }

        internal virtual void addLink(Erlang.Pid local, Erlang.Pid remote)
        {
            lock(this)
            {
                int i;

                if ((i = find(local, remote)) == - 1)
                {
                    if (_count >= _links.Length)
                    {
                        Link[] tmp = new Link[_count * 2];
                        Array.Copy(_links, 0, tmp, 0, _count);
                        _links = tmp;
                    }
                    _links[_count++] = new Link(local, remote);
                }
            }
        }

 // exit (etc) has from, to, reason
 internal OtpMsg(Tag tag, Erlang.Pid from, Erlang.Pid to, Erlang.Object reason)
     : this(tag, from, to, null, reason, null)
 {
 }

 /*
 * Create a stream containing the encoded version of the given
 * Erlang term.
 **/
 public OtpOutputStream(Erlang.Object o)
     : this()
 {
     this.write_any(o);
 }

 public override bool match(Erlang.Object pattern, VarBind binding)
 {
     if (pattern is Erlang.Var)
         pattern.match(this, binding);
     else if (!(pattern is Erlang.List))
         return false;
     Erlang.List tup = pattern as Erlang.List;
     if (arity() != tup.arity())
         return false;
     for (int i = 0; i < arity(); ++i)
         if (!elems[i].match(tup[i], binding))
             return false;
     return true;
 }

 /*
 * <p> Send an exit signal to a remote {@link Pid pid}.
 * This method does not cause any links to be broken, except
 * indirectly if the remote {@link Pid pid} exits as a
 * result of this exit signal. </p>
 *
 * @param to the {@link Pid pid} to which the exit signal
 * should be sent.
 *
 * @param reason a string indicating the reason for the exit.
 **/
 // it's called exit, but it sends exit2
 public virtual void exit(Erlang.Pid to, System.String reason)
 {
     exit(2, to, reason);
 }

 public virtual bool equals(Erlang.Pid local, Erlang.Pid remote)
 {
     return ((this._local.Equals(local) && this._remote.Equals(remote)) ||
             (this._local.Equals(remote) && this._remote.Equals(local)));
 }

 public virtual bool contains(Erlang.Pid pid)
 {
     return (this._local.Equals(pid) || this._remote.Equals(pid));
 }

 public Link(Erlang.Pid local, Erlang.Pid remote)
 {
     this._local = local;
     this._remote = remote;
 }

 // package constructor: called by OtpNode:createMbox()
 // to create an anonymous
 internal OtpMbox(OtpNode home, Erlang.Pid self)
     : this(home, self, null)
 {
 }

        public override bool subst(ref Erlang.Object a_term, VarBind binding)
        {
            System.Collections.Generic.List<Erlang.Object> result =
                new System.Collections.Generic.List<Erlang.Object>();
            bool changed = false;

            foreach (Erlang.Object term in this.elems)
            {
                Erlang.Object obj = null;
                if (term.subst(ref obj, binding))
                    result.Add(obj);
                else
                {
                    changed = true;
                    result.Add(term);
                }
            }

            if (!changed)
                return false;

            a_term = new Erlang.List(result.ToArray());
            return true;
        }

        /*
        * <p> Link to a remote mailbox or Erlang process. Links are
        * idempotent, calling this method multiple times will not result in
        * more than one link being created. </p>
        *
        * <p> If the remote process subsequently exits or the mailbox is
        * closed, a subsequent attempt to retrieve a message through this
        * mailbox will cause an {@link Exit Exit}
        * exception to be raised. Similarly, if the sending mailbox is
        * closed, the linked mailbox or process will receive an exit
        * signal. </p>
        *
        * <p> If the remote process cannot be reached in order to set the
        * link, the exception is raised immediately. </p>
        *
        * @param to the {@link Pid pid} representing the object to
        * link to.
        *
        * @exception Exit if the {@link Pid pid} referred
        * to does not exist or could not be reached.
        *
        **/
        public virtual void link(Erlang.Pid to)
        {
            try
            {
                System.String node = to.node();
                if (node.Equals(home.node()))
                {
                    if (!home.deliver(new OtpMsg(OtpMsg.linkTag, _self, to)))
                    {
                        throw new Erlang.Exit("noproc", to);
                    }
                }
                else
                {
                    OtpCookedConnection conn = home.getConnection(node);
                    if (conn != null)
                        conn.link(_self, to);
                    else
                        throw new Erlang.Exit("noproc", to);
                }
            }
            catch (Erlang.Exit e)
            {
                throw e;
            }
            catch (System.Exception)
            {
            }

            links.addLink(_self, to);
        }

        /*
        This does not work when char > 1 byte Unicode is used

        public void write_string(String s) {
        this.write1(OtpExternal.stringTag);
        this.write2BE(s.length());
        this.writeN(s.getBytes());
        }*/
        /*
        * Write an arbitrary Erlang term to the stream.
        *
        * @param o the Erlang term to write.
        */
        public virtual void write_any(Erlang.Object o)
        {
            // calls one of the above functions, depending on o
            o.encode(this);
        }

 /*
 * Send a message to a remote {@link Pid pid}, representing
 * either another {@link OtpMbox mailbox} or an Erlang process.
 *
 * @param to the {@link Pid pid} identifying the intended
 * recipient of the message.
 *
 * @param msg the body of the message to send.
 *
 **/
 public virtual void send(Erlang.Pid to, Erlang.Object msg)
 {
     try
     {
         System.String node = to.node();
         if (node.Equals(home.node()))
         {
             home.deliver(new OtpMsg(to, (Erlang.Object) (msg.clone())));
         }
         else
         {
             OtpCookedConnection conn = home.getConnection(node);
             if (conn == null)
                 return ;
             conn.send(_self, to, msg);
         }
     }
     catch (System.Exception)
     {
     }
 }

        /*
        * <p> Remove a link to a remote mailbox or Erlang process. This
        * method removes a link created with {@link #link link()}.
        * Links are idempotent; calling this method once will remove all
        * links between this mailbox and the remote {@link Pid
        * pid}. </p>
        *
        * @param to the {@link Pid pid} representing the object to
        * unlink from.
        *
        **/
        public virtual void unlink(Erlang.Pid to)
        {
            links.removeLink(_self, to);

            try
            {
                System.String node = to.node();
                if (node.Equals(home.node()))
                {
                    home.deliver(new OtpMsg(OtpMsg.unlinkTag, _self, to));
                }
                else
                {
                    OtpCookedConnection conn = home.getConnection(node);
                    if (conn != null)
                        conn.unlink(_self, to);
                }
            }
            catch (System.Exception)
            {
            }
        }