public override void write__(Ice.OutputStream outS__)
 {
     Ice.MarshalException ex = new Ice.MarshalException();
     ex.reason = "exception Murmur::InvalidChannelException was not generated with stream support";
     throw ex;
 }

 public override void read__(Ice.InputStream inS__, bool rid__)
 {
     Ice.MarshalException ex = new Ice.MarshalException();
     ex.reason = "exception Murmur::InvalidChannelException was not generated with stream support";
     throw ex;
 }

        private void reserve(int n)
        {
            Debug.Assert(_capacity == b.capacity());

            if(n > _capacity)
            {
                _capacity = System.Math.Max(n, System.Math.Min(2 * _capacity, _maxCapacity));
                _capacity = System.Math.Max(240, _capacity);
            }
            else if(n < _capacity)
            {
                _capacity = n;
            }
            else
            {
                return;
            }

            try
            {
                ByteBuffer buf = ByteBuffer.allocate(_capacity);

                if(b == _emptyBuffer)
                {
                    b = buf;
                }
                else
                {
                    int pos = b.position();
                    b.position(0);
                    b.limit(System.Math.Min(_capacity, b.capacity()));
                    buf.put(b);
                    b = buf;
                    b.limit(b.capacity());
                    b.position(pos);
                }

                b.order(ByteBuffer.ByteOrder.LITTLE_ENDIAN);
            }
            catch(System.OutOfMemoryException)
            {
                _capacity = b.capacity(); // Restore the previous capacity
                throw;
            }
            catch(System.Exception ex)
            {
                _capacity = b.capacity(); // Restore the previous capacity.
                Ice.MarshalException e = new Ice.MarshalException(ex);
                e.reason = "unexpected exception while trying to allocate a ByteBuffer:\n" + ex;
                throw e;
            }
            finally
            {
                Debug.Assert(_capacity == b.capacity());
            }
        }

 protected static void checkMode__(OperationMode expected, OperationMode received)
 {
     if(expected != received)
     {
         if(expected == OperationMode.Idempotent && received == OperationMode.Nonmutating)
         {
             //
             // Fine: typically an old client still using the
             // deprecated nonmutating keyword
             //
         }
         else
         {
             Ice.MarshalException ex = new Ice.MarshalException();
             ex.reason = "unexpected operation mode. expected = " + operationModeToString(expected) +
                 " received = " + operationModeToString(received);
             throw ex;
         }
     }
 }