src/test/csharp/Commands/StreamMessage.cs - activemq-nms-xms - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 using System;
 using System.IO;
 using System.Collections;

 using Apache.NMS;
 using Apache.NMS.Util;

 namespace Apache.NMS.Commands
 {
     public class StreamMessage : Message, IStreamMessage
     {
         private EndianBinaryReader dataIn = null;
         private EndianBinaryWriter dataOut = null;
         private MemoryStream byteBuffer = null;
         private int bytesRemaining = -1;

         public bool ReadBoolean()
         {
             InitializeReading();

             try
             {
                 long startingPos = this.byteBuffer.Position;
                 try
                 {
                     int type = this.dataIn.ReadByte();

                     if(type == PrimitiveMap.BOOLEAN_TYPE)
                     {
                         return this.dataIn.ReadBoolean();
                     }
                     else if(type == PrimitiveMap.STRING_TYPE)
                     {
                         return Boolean.Parse(this.dataIn.ReadString16());
                     }
                     else if(type == PrimitiveMap.NULL)
                     {
                         this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
                         throw new NMSException("Cannot convert Null type to a bool");
                     }
                     else
                     {
                         this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
                         throw new MessageFormatException("Value is not a Boolean type.");
                     }
                 }
                 catch(FormatException e)
                 {
                     this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
                     throw NMSExceptionSupport.CreateMessageFormatException(e);
                 }
             }
             catch(EndOfStreamException e)
             {
                 throw NMSExceptionSupport.CreateMessageEOFException(e);
             }
             catch(IOException e)
             {
                 throw NMSExceptionSupport.CreateMessageFormatException(e);
             }
         }

         public byte ReadByte()
         {
             InitializeReading();

             try
             {
                 long startingPos = this.byteBuffer.Position;
                 try
                 {
                     int type = this.dataIn.ReadByte();

                     if(type == PrimitiveMap.BYTE_TYPE)
                     {
                         return this.dataIn.ReadByte();
                     }
                     else if(type == PrimitiveMap.STRING_TYPE)
                     {
                         return Byte.Parse(this.dataIn.ReadString16());
                     }
                     else if(type == PrimitiveMap.NULL)
                     {
                         this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
                         throw new NMSException("Cannot convert Null type to a byte");
                     }
                     else
                     {
                         this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
                         throw new MessageFormatException("Value is not a Byte type.");
                     }
                 }
                 catch(FormatException e)
                 {
                     this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
                     throw NMSExceptionSupport.CreateMessageFormatException(e);
                 }
             }
             catch(EndOfStreamException e)
             {
                 throw NMSExceptionSupport.CreateMessageEOFException(e);
             }
             catch(IOException e)
             {
                 throw NMSExceptionSupport.CreateMessageFormatException(e);
             }
         }

         public char ReadChar()
         {
             InitializeReading();

             try
             {
                 long startingPos = this.byteBuffer.Position;
                 try
                 {
                     int type = this.dataIn.ReadByte();

                     if(type == PrimitiveMap.CHAR_TYPE)
                     {
                         return this.dataIn.ReadChar();
                     }
                     else if(type == PrimitiveMap.NULL)
                     {
                         this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
                         throw new NMSException("Cannot convert Null type to a char");
                     }
                     else
                     {
                         this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
                         throw new MessageFormatException("Value is not a Char type.");
                     }
                 }
                 catch(FormatException e)
                 {
                     this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
                     throw NMSExceptionSupport.CreateMessageFormatException(e);
                 }
             }
             catch(EndOfStreamException e)
             {
                 throw NMSExceptionSupport.CreateMessageEOFException(e);
             }
             catch(IOException e)
             {
                 throw NMSExceptionSupport.CreateMessageFormatException(e);
             }
         }

         public short ReadInt16()
         {
             InitializeReading();

             try
             {
                 long startingPos = this.byteBuffer.Position;
                 try
                 {
                     int type = this.dataIn.ReadByte();

                     if(type == PrimitiveMap.SHORT_TYPE)
                     {
                         return this.dataIn.ReadInt16();
                     }
                     else if(type == PrimitiveMap.BYTE_TYPE)
                     {
                         return this.dataIn.ReadByte();
                     }
                     else if(type == PrimitiveMap.STRING_TYPE)
                     {
                         return Int16.Parse(this.dataIn.ReadString16());
                     }
                     else if(type == PrimitiveMap.NULL)
                     {
                         this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
                         throw new NMSException("Cannot convert Null type to a short");
                     }
                     else
                     {
                         this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
                         throw new MessageFormatException("Value is not a Int16 type.");
                     }
                 }
                 catch(FormatException e)
                 {
                     this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
                     throw NMSExceptionSupport.CreateMessageFormatException(e);
                 }
             }
             catch(EndOfStreamException e)
             {
                 throw NMSExceptionSupport.CreateMessageEOFException(e);
             }
             catch(IOException e)
             {
                 throw NMSExceptionSupport.CreateMessageFormatException(e);
             }
         }

         public int ReadInt32()
         {
             InitializeReading();

             try
             {
                 long startingPos = this.byteBuffer.Position;
                 try
                 {
                     int type = this.dataIn.ReadByte();

                     if(type == PrimitiveMap.INTEGER_TYPE)
                     {
                         return this.dataIn.ReadInt32();
                     }
                     else if(type == PrimitiveMap.SHORT_TYPE)
                     {
                         return this.dataIn.ReadInt16();
                     }
                     else if(type == PrimitiveMap.BYTE_TYPE)
                     {
                         return this.dataIn.ReadByte();
                     }
                     else if(type == PrimitiveMap.STRING_TYPE)
                     {
                         return Int32.Parse(this.dataIn.ReadString16());
                     }
                     else if(type == PrimitiveMap.NULL)
                     {
                         this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
                         throw new NMSException("Cannot convert Null type to a int");
                     }
                     else
                     {
                         this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
                         throw new MessageFormatException("Value is not a Int32 type.");
                     }
                 }
                 catch(FormatException e)
                 {
                     this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
                     throw NMSExceptionSupport.CreateMessageFormatException(e);
                 }
             }
             catch(EndOfStreamException e)
             {
                 throw NMSExceptionSupport.CreateMessageEOFException(e);
             }
             catch(IOException e)
             {
                 throw NMSExceptionSupport.CreateMessageFormatException(e);
             }
         }

         public long ReadInt64()
         {
             InitializeReading();

             try
             {
                 long startingPos = this.byteBuffer.Position;
                 try
                 {
                     int type = this.dataIn.ReadByte();

                     if(type == PrimitiveMap.LONG_TYPE)
                     {
                         return this.dataIn.ReadInt64();
                     }
                     else if(type == PrimitiveMap.INTEGER_TYPE)
                     {
                         return this.dataIn.ReadInt32();
                     }
                     else if(type == PrimitiveMap.SHORT_TYPE)
                     {
                         return this.dataIn.ReadInt16();
                     }
                     else if(type == PrimitiveMap.BYTE_TYPE)
                     {
                         return this.dataIn.ReadByte();
                     }
                     else if(type == PrimitiveMap.STRING_TYPE)
                     {
                         return Int64.Parse(this.dataIn.ReadString16());
                     }
                     else if(type == PrimitiveMap.NULL)
                     {
                         this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
                         throw new NMSException("Cannot convert Null type to a long");
                     }
                     else
                     {
                         this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
                         throw new MessageFormatException("Value is not a Int64 type.");
                     }
                 }
                 catch(FormatException e)
                 {
                     this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
                     throw NMSExceptionSupport.CreateMessageFormatException(e);
                 }
             }
             catch(EndOfStreamException e)
             {
                 throw NMSExceptionSupport.CreateMessageEOFException(e);
             }
             catch(IOException e)
             {
                 throw NMSExceptionSupport.CreateMessageFormatException(e);
             }
         }

         public float ReadSingle()
         {
             InitializeReading();

             try
             {
                 long startingPos = this.byteBuffer.Position;
                 try
                 {
                     int type = this.dataIn.ReadByte();

                     if(type == PrimitiveMap.FLOAT_TYPE)
                     {
                         return this.dataIn.ReadSingle();
                     }
                     else if(type == PrimitiveMap.STRING_TYPE)
                     {
                         return Single.Parse(this.dataIn.ReadString16());
                     }
                     else if(type == PrimitiveMap.NULL)
                     {
                         this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
                         throw new NMSException("Cannot convert Null type to a float");
                     }
                     else
                     {
                         this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
                         throw new MessageFormatException("Value is not a Single type.");
                     }
                 }
                 catch(FormatException e)
                 {
                     this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
                     throw NMSExceptionSupport.CreateMessageFormatException(e);
                 }
             }
             catch(EndOfStreamException e)
             {
                 throw NMSExceptionSupport.CreateMessageEOFException(e);
             }
             catch(IOException e)
             {
                 throw NMSExceptionSupport.CreateMessageFormatException(e);
             }
         }

         public double ReadDouble()
         {
             InitializeReading();

             try
             {
                 long startingPos = this.byteBuffer.Position;
                 try
                 {
                     int type = this.dataIn.ReadByte();

                     if(type == PrimitiveMap.DOUBLE_TYPE)
                     {
                         return this.dataIn.ReadDouble();
                     }
                     else if(type == PrimitiveMap.FLOAT_TYPE)
                     {
                         return this.dataIn.ReadSingle();
                     }
                     else if(type == PrimitiveMap.STRING_TYPE)
                     {
                         return Single.Parse(this.dataIn.ReadString16());
                     }
                     else if(type == PrimitiveMap.NULL)
                     {
                         this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
                         throw new NMSException("Cannot convert Null type to a double");
                     }
                     else
                     {
                         this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
                         throw new MessageFormatException("Value is not a Double type.");
                     }
                 }
                 catch(FormatException e)
                 {
                     this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
                     throw NMSExceptionSupport.CreateMessageFormatException(e);
                 }
             }
             catch(EndOfStreamException e)
             {
                 throw NMSExceptionSupport.CreateMessageEOFException(e);
             }
             catch(IOException e)
             {
                 throw NMSExceptionSupport.CreateMessageFormatException(e);
             }
         }

         public string ReadString()
         {
             InitializeReading();

             long startingPos = this.byteBuffer.Position;

             try
             {
                 int type = this.dataIn.ReadByte();

                 if(type == PrimitiveMap.BIG_STRING_TYPE)
                 {
                     return this.dataIn.ReadString32();
                 }
                 else if(type == PrimitiveMap.STRING_TYPE)
                 {
                     return this.dataIn.ReadString16();
                 }
                 else if(type == PrimitiveMap.LONG_TYPE)
                 {
                     return this.dataIn.ReadInt64().ToString();
                 }
                 else if(type == PrimitiveMap.INTEGER_TYPE)
                 {
                     return this.dataIn.ReadInt32().ToString();
                 }
                 else if(type == PrimitiveMap.SHORT_TYPE)
                 {
                     return this.dataIn.ReadInt16().ToString();
                 }
                 else if(type == PrimitiveMap.FLOAT_TYPE)
                 {
                     return this.dataIn.ReadSingle().ToString();
                 }
                 else if(type == PrimitiveMap.DOUBLE_TYPE)
                 {
                     return this.dataIn.ReadDouble().ToString();
                 }
                 else if(type == PrimitiveMap.CHAR_TYPE)
                 {
                     return this.dataIn.ReadChar().ToString();
                 }
                 else if(type == PrimitiveMap.BYTE_TYPE)
                 {
                     return this.dataIn.ReadByte().ToString();
                 }
                 else if(type == PrimitiveMap.BOOLEAN_TYPE)
                 {
                     return this.dataIn.ReadBoolean().ToString();
                 }
                 else if(type == PrimitiveMap.NULL)
                 {
                     return null;
                 }
                 else
                 {
                     this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
                     throw new MessageFormatException("Value is not a known type.");
                 }
             }
             catch(FormatException e)
             {
                 this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
                 throw NMSExceptionSupport.CreateMessageFormatException(e);
             }
             catch(EndOfStreamException e)
             {
                 throw NMSExceptionSupport.CreateMessageEOFException(e);
             }
             catch(IOException e)
             {
                 throw NMSExceptionSupport.CreateMessageFormatException(e);
             }
         }

         public int ReadBytes(byte[] value)
         {
             InitializeReading();

             if(value == null)
             {
                 throw new NullReferenceException("Passed Byte Array is null");
             }

             try
             {
                 if(this.bytesRemaining == -1)
                 {
                     long startingPos = this.byteBuffer.Position;
                     byte type = this.dataIn.ReadByte();

                     if(type != PrimitiveMap.BYTE_ARRAY_TYPE)
                     {
                         this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
                         throw new MessageFormatException("Not a byte array");
                     }

                     this.bytesRemaining = this.dataIn.ReadInt32();
                 }
                 else if(this.bytesRemaining == 0)
                 {
                     this.bytesRemaining = -1;
                     return -1;
                 }

                 if(value.Length <= this.bytesRemaining)
                 {
                     // small buffer
                     this.bytesRemaining -= value.Length;
                     this.dataIn.Read(value, 0, value.Length);
                     return value.Length;
                 }
                 else
                 {
                     // big buffer
                     int rc = this.dataIn.Read(value, 0, this.bytesRemaining);
                     this.bytesRemaining = 0;
                     return rc;
                 }
             }
             catch(EndOfStreamException ex)
             {
                 throw NMSExceptionSupport.CreateMessageEOFException(ex);
             }
             catch(IOException ex)
             {
                 throw NMSExceptionSupport.CreateMessageFormatException(ex);
             }
         }

         public Object ReadObject()
         {
             InitializeReading();

             long startingPos = this.byteBuffer.Position;

             try
             {
                 int type = this.dataIn.ReadByte();

                 if(type == PrimitiveMap.BIG_STRING_TYPE)
                 {
                     return this.dataIn.ReadString32();
                 }
                 else if(type == PrimitiveMap.STRING_TYPE)
                 {
                     return this.dataIn.ReadString16();
                 }
                 else if(type == PrimitiveMap.LONG_TYPE)
                 {
                     return this.dataIn.ReadInt64();
                 }
                 else if(type == PrimitiveMap.INTEGER_TYPE)
                 {
                     return this.dataIn.ReadInt32();
                 }
                 else if(type == PrimitiveMap.SHORT_TYPE)
                 {
                     return this.dataIn.ReadInt16();
                 }
                 else if(type == PrimitiveMap.FLOAT_TYPE)
                 {
                     return this.dataIn.ReadSingle();
                 }
                 else if(type == PrimitiveMap.DOUBLE_TYPE)
                 {
                     return this.dataIn.ReadDouble();
                 }
                 else if(type == PrimitiveMap.CHAR_TYPE)
                 {
                     return this.dataIn.ReadChar();
                 }
                 else if(type == PrimitiveMap.BYTE_TYPE)
                 {
                     return this.dataIn.ReadByte();
                 }
                 else if(type == PrimitiveMap.BOOLEAN_TYPE)
                 {
                     return this.dataIn.ReadBoolean();
                 }
                 else if(type == PrimitiveMap.BYTE_ARRAY_TYPE)
                 {
                     int length = this.dataIn.ReadInt32();
                     byte[] data = new byte[length];
                     this.dataIn.Read(data, 0, length);
                     return data;
                 }
                 else if(type == PrimitiveMap.NULL)
                 {
                     return null;
                 }
                 else
                 {
                     this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
                     throw new MessageFormatException("Value is not a known type.");
                 }
             }
             catch(FormatException e)
             {
                 this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
                 throw NMSExceptionSupport.CreateMessageFormatException(e);
             }
             catch(EndOfStreamException e)
             {
                 throw NMSExceptionSupport.CreateMessageEOFException(e);
             }
             catch(IOException e)
             {
                 throw NMSExceptionSupport.CreateMessageFormatException(e);
             }
         }

         public void WriteBoolean(bool value)
         {
             InitializeWriting();
             try
             {
                 this.dataOut.Write(PrimitiveMap.BOOLEAN_TYPE);
                 this.dataOut.Write(value);
             }
             catch(IOException e)
             {
                 NMSExceptionSupport.Create(e);
             }
         }

         public void WriteByte(byte value)
         {
             InitializeWriting();
             try
             {
                 this.dataOut.Write(PrimitiveMap.BYTE_TYPE);
                 this.dataOut.Write(value);
             }
             catch(IOException e)
             {
                 NMSExceptionSupport.Create(e);
             }
         }

         public void WriteBytes(byte[] value)
         {
             InitializeWriting();
             this.WriteBytes(value, 0, value.Length);
         }

         public void WriteBytes(byte[] value, int offset, int length)
         {
             InitializeWriting();
             try
             {
                 this.dataOut.Write(PrimitiveMap.BYTE_ARRAY_TYPE);
                 this.dataOut.Write((int) length);
                 this.dataOut.Write(value, offset, length);
             }
             catch(IOException e)
             {
                 NMSExceptionSupport.Create(e);
             }
         }

         public void WriteChar(char value)
         {
             InitializeWriting();
             try
             {
                 this.dataOut.Write(PrimitiveMap.CHAR_TYPE);
                 this.dataOut.Write(value);
             }
             catch(IOException e)
             {
                 NMSExceptionSupport.Create(e);
             }
         }

         public void WriteInt16(short value)
         {
             InitializeWriting();
             try
             {
                 this.dataOut.Write(PrimitiveMap.SHORT_TYPE);
                 this.dataOut.Write(value);
             }
             catch(IOException e)
             {
                 NMSExceptionSupport.Create(e);
             }
         }

         public void WriteInt32(int value)
         {
             InitializeWriting();
             try
             {
                 this.dataOut.Write(PrimitiveMap.INTEGER_TYPE);
                 this.dataOut.Write(value);
             }
             catch(IOException e)
             {
                 NMSExceptionSupport.Create(e);
             }
         }

         public void WriteInt64(long value)
         {
             InitializeWriting();
             try
             {
                 this.dataOut.Write(PrimitiveMap.LONG_TYPE);
                 this.dataOut.Write(value);
             }
             catch(IOException e)
             {
                 NMSExceptionSupport.Create(e);
             }
         }

         public void WriteSingle(float value)
         {
             InitializeWriting();
             try
             {
                 this.dataOut.Write(PrimitiveMap.FLOAT_TYPE);
                 this.dataOut.Write(value);
             }
             catch(IOException e)
             {
                 NMSExceptionSupport.Create(e);
             }
         }

         public void WriteDouble(double value)
         {
             InitializeWriting();
             try
             {
                 this.dataOut.Write(PrimitiveMap.DOUBLE_TYPE);
                 this.dataOut.Write(value);
             }
             catch(IOException e)
             {
                 NMSExceptionSupport.Create(e);
             }
         }

         public void WriteString(string value)
         {
             InitializeWriting();
             try
             {
                 if( value.Length > 8192 )
                 {
                     this.dataOut.Write(PrimitiveMap.BIG_STRING_TYPE);
                     this.dataOut.WriteString32(value);
                 }
                 else
                 {
                     this.dataOut.Write(PrimitiveMap.STRING_TYPE);
                     this.dataOut.WriteString16(value);
                 }
             }
             catch(IOException e)
             {
                 NMSExceptionSupport.Create(e);
             }
         }

         public void WriteObject(Object value)
         {
             InitializeWriting();
             if( value is System.Byte )
             {
                 this.WriteByte( (byte) value );
             }
             else if( value is Char )
             {
                 this.WriteChar( (char) value );
             }
             else if( value is Boolean )
             {
                 this.WriteBoolean( (bool) value );
             }
             else if( value is Int16 )
             {
                 this.WriteInt16( (short) value );
             }
             else if( value is Int32 )
             {
                 this.WriteInt32( (int) value );
             }
             else if( value is Int64 )
             {
                 this.WriteInt64( (long) value );
             }
             else if( value is Single )
             {
                 this.WriteSingle( (float) value );
             }
             else if( value is Double )
             {
                 this.WriteDouble( (double) value );
             }
             else if( value is byte[] )
             {
                 this.WriteBytes( (byte[]) value );
             }
             else if( value is String )
             {
                 this.WriteString( (string) value );
             }
             else
             {
                 throw new MessageFormatException("Cannot write non-primitive type:" + value.GetType());
             }
         }

         public override Object Clone()
         {
             StoreContent();
             return base.Clone();
         }

         public override void ClearBody()
         {
             base.ClearBody();
             this.byteBuffer = null;
             this.dataIn = null;
             this.dataOut = null;
             this.bytesRemaining = -1;
         }

         public void Reset()
         {
             StoreContent();
             this.dataIn = null;
             this.dataOut = null;
             this.byteBuffer = null;
             this.bytesRemaining = -1;
             this.ReadOnlyBody = true;
         }

         private void InitializeReading()
         {
             FailIfWriteOnlyBody();
             if(this.dataIn == null)
             {
                 this.byteBuffer = new MemoryStream(this.Content, false);
                 this.dataIn = new EndianBinaryReader(this.byteBuffer);
             }
         }

         private void InitializeWriting()
         {
             FailIfReadOnlyBody();
             if(this.dataOut == null)
             {
                 this.byteBuffer = new MemoryStream();
                 this.dataOut = new EndianBinaryWriter(this.byteBuffer);
             }
         }

         private void StoreContent()
         {
             if( dataOut != null)
             {
                 dataOut.Close();

                 this.Content = byteBuffer.ToArray();
                 this.dataOut = null;
                 this.byteBuffer = null;
             }
         }

     }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	using System;
	using System.IO;
	using System.Collections;

	using Apache.NMS;
	using Apache.NMS.Util;

	namespace Apache.NMS.Commands
	{
	public class StreamMessage : Message, IStreamMessage
	{
	private EndianBinaryReader dataIn = null;
	private EndianBinaryWriter dataOut = null;
	private MemoryStream byteBuffer = null;
	private int bytesRemaining = -1;

	public bool ReadBoolean()
	{
	InitializeReading();

	try
	{
	long startingPos = this.byteBuffer.Position;
	try
	{
	int type = this.dataIn.ReadByte();

	if(type == PrimitiveMap.BOOLEAN_TYPE)
	{
	return this.dataIn.ReadBoolean();
	}
	else if(type == PrimitiveMap.STRING_TYPE)
	{
	return Boolean.Parse(this.dataIn.ReadString16());
	}
	else if(type == PrimitiveMap.NULL)
	{
	this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
	throw new NMSException("Cannot convert Null type to a bool");
	}
	else
	{
	this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
	throw new MessageFormatException("Value is not a Boolean type.");
	}
	}
	catch(FormatException e)
	{
	this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
	throw NMSExceptionSupport.CreateMessageFormatException(e);
	}
	}
	catch(EndOfStreamException e)
	{
	throw NMSExceptionSupport.CreateMessageEOFException(e);
	}
	catch(IOException e)
	{
	throw NMSExceptionSupport.CreateMessageFormatException(e);
	}
	}

	public byte ReadByte()
	{
	InitializeReading();

	try
	{
	long startingPos = this.byteBuffer.Position;
	try
	{
	int type = this.dataIn.ReadByte();

	if(type == PrimitiveMap.BYTE_TYPE)
	{
	return this.dataIn.ReadByte();
	}
	else if(type == PrimitiveMap.STRING_TYPE)
	{
	return Byte.Parse(this.dataIn.ReadString16());
	}
	else if(type == PrimitiveMap.NULL)
	{
	this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
	throw new NMSException("Cannot convert Null type to a byte");
	}
	else
	{
	this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
	throw new MessageFormatException("Value is not a Byte type.");
	}
	}
	catch(FormatException e)
	{
	this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
	throw NMSExceptionSupport.CreateMessageFormatException(e);
	}
	}
	catch(EndOfStreamException e)
	{
	throw NMSExceptionSupport.CreateMessageEOFException(e);
	}
	catch(IOException e)
	{
	throw NMSExceptionSupport.CreateMessageFormatException(e);
	}
	}

	public char ReadChar()
	{
	InitializeReading();

	try
	{
	long startingPos = this.byteBuffer.Position;
	try
	{
	int type = this.dataIn.ReadByte();

	if(type == PrimitiveMap.CHAR_TYPE)
	{
	return this.dataIn.ReadChar();
	}
	else if(type == PrimitiveMap.NULL)
	{
	this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
	throw new NMSException("Cannot convert Null type to a char");
	}
	else
	{
	this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
	throw new MessageFormatException("Value is not a Char type.");
	}
	}
	catch(FormatException e)
	{
	this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
	throw NMSExceptionSupport.CreateMessageFormatException(e);
	}
	}
	catch(EndOfStreamException e)
	{
	throw NMSExceptionSupport.CreateMessageEOFException(e);
	}
	catch(IOException e)
	{
	throw NMSExceptionSupport.CreateMessageFormatException(e);
	}
	}

	public short ReadInt16()
	{
	InitializeReading();

	try
	{
	long startingPos = this.byteBuffer.Position;
	try
	{
	int type = this.dataIn.ReadByte();

	if(type == PrimitiveMap.SHORT_TYPE)
	{
	return this.dataIn.ReadInt16();
	}
	else if(type == PrimitiveMap.BYTE_TYPE)
	{
	return this.dataIn.ReadByte();
	}
	else if(type == PrimitiveMap.STRING_TYPE)
	{
	return Int16.Parse(this.dataIn.ReadString16());
	}
	else if(type == PrimitiveMap.NULL)
	{
	this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
	throw new NMSException("Cannot convert Null type to a short");
	}
	else
	{
	this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
	throw new MessageFormatException("Value is not a Int16 type.");
	}
	}
	catch(FormatException e)
	{
	this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
	throw NMSExceptionSupport.CreateMessageFormatException(e);
	}
	}
	catch(EndOfStreamException e)
	{
	throw NMSExceptionSupport.CreateMessageEOFException(e);
	}
	catch(IOException e)
	{
	throw NMSExceptionSupport.CreateMessageFormatException(e);
	}
	}

	public int ReadInt32()
	{
	InitializeReading();

	try
	{
	long startingPos = this.byteBuffer.Position;
	try
	{
	int type = this.dataIn.ReadByte();

	if(type == PrimitiveMap.INTEGER_TYPE)
	{
	return this.dataIn.ReadInt32();
	}
	else if(type == PrimitiveMap.SHORT_TYPE)
	{
	return this.dataIn.ReadInt16();
	}
	else if(type == PrimitiveMap.BYTE_TYPE)
	{
	return this.dataIn.ReadByte();
	}
	else if(type == PrimitiveMap.STRING_TYPE)
	{
	return Int32.Parse(this.dataIn.ReadString16());
	}
	else if(type == PrimitiveMap.NULL)
	{
	this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
	throw new NMSException("Cannot convert Null type to a int");
	}
	else
	{
	this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
	throw new MessageFormatException("Value is not a Int32 type.");
	}
	}
	catch(FormatException e)
	{
	this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
	throw NMSExceptionSupport.CreateMessageFormatException(e);
	}
	}
	catch(EndOfStreamException e)
	{
	throw NMSExceptionSupport.CreateMessageEOFException(e);
	}
	catch(IOException e)
	{
	throw NMSExceptionSupport.CreateMessageFormatException(e);
	}
	}

	public long ReadInt64()
	{
	InitializeReading();

	try
	{
	long startingPos = this.byteBuffer.Position;
	try
	{
	int type = this.dataIn.ReadByte();

	if(type == PrimitiveMap.LONG_TYPE)
	{
	return this.dataIn.ReadInt64();
	}
	else if(type == PrimitiveMap.INTEGER_TYPE)
	{
	return this.dataIn.ReadInt32();
	}
	else if(type == PrimitiveMap.SHORT_TYPE)
	{
	return this.dataIn.ReadInt16();
	}
	else if(type == PrimitiveMap.BYTE_TYPE)
	{
	return this.dataIn.ReadByte();
	}
	else if(type == PrimitiveMap.STRING_TYPE)
	{
	return Int64.Parse(this.dataIn.ReadString16());
	}
	else if(type == PrimitiveMap.NULL)
	{
	this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
	throw new NMSException("Cannot convert Null type to a long");
	}
	else
	{
	this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
	throw new MessageFormatException("Value is not a Int64 type.");
	}
	}
	catch(FormatException e)
	{
	this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
	throw NMSExceptionSupport.CreateMessageFormatException(e);
	}
	}
	catch(EndOfStreamException e)
	{
	throw NMSExceptionSupport.CreateMessageEOFException(e);
	}
	catch(IOException e)
	{
	throw NMSExceptionSupport.CreateMessageFormatException(e);
	}
	}

	public float ReadSingle()
	{
	InitializeReading();

	try
	{
	long startingPos = this.byteBuffer.Position;
	try
	{
	int type = this.dataIn.ReadByte();

	if(type == PrimitiveMap.FLOAT_TYPE)
	{
	return this.dataIn.ReadSingle();
	}
	else if(type == PrimitiveMap.STRING_TYPE)
	{
	return Single.Parse(this.dataIn.ReadString16());
	}
	else if(type == PrimitiveMap.NULL)
	{
	this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
	throw new NMSException("Cannot convert Null type to a float");
	}
	else
	{
	this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
	throw new MessageFormatException("Value is not a Single type.");
	}
	}
	catch(FormatException e)
	{
	this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
	throw NMSExceptionSupport.CreateMessageFormatException(e);
	}
	}
	catch(EndOfStreamException e)
	{
	throw NMSExceptionSupport.CreateMessageEOFException(e);
	}
	catch(IOException e)
	{
	throw NMSExceptionSupport.CreateMessageFormatException(e);
	}
	}

	public double ReadDouble()
	{
	InitializeReading();

	try
	{
	long startingPos = this.byteBuffer.Position;
	try
	{
	int type = this.dataIn.ReadByte();

	if(type == PrimitiveMap.DOUBLE_TYPE)
	{
	return this.dataIn.ReadDouble();
	}
	else if(type == PrimitiveMap.FLOAT_TYPE)
	{
	return this.dataIn.ReadSingle();
	}
	else if(type == PrimitiveMap.STRING_TYPE)
	{
	return Single.Parse(this.dataIn.ReadString16());
	}
	else if(type == PrimitiveMap.NULL)
	{
	this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
	throw new NMSException("Cannot convert Null type to a double");
	}
	else
	{
	this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
	throw new MessageFormatException("Value is not a Double type.");
	}
	}
	catch(FormatException e)
	{
	this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
	throw NMSExceptionSupport.CreateMessageFormatException(e);
	}
	}
	catch(EndOfStreamException e)
	{
	throw NMSExceptionSupport.CreateMessageEOFException(e);
	}
	catch(IOException e)
	{
	throw NMSExceptionSupport.CreateMessageFormatException(e);
	}
	}

	public string ReadString()
	{
	InitializeReading();

	long startingPos = this.byteBuffer.Position;

	try
	{
	int type = this.dataIn.ReadByte();

	if(type == PrimitiveMap.BIG_STRING_TYPE)
	{
	return this.dataIn.ReadString32();
	}
	else if(type == PrimitiveMap.STRING_TYPE)
	{
	return this.dataIn.ReadString16();
	}
	else if(type == PrimitiveMap.LONG_TYPE)
	{
	return this.dataIn.ReadInt64().ToString();
	}
	else if(type == PrimitiveMap.INTEGER_TYPE)
	{
	return this.dataIn.ReadInt32().ToString();
	}
	else if(type == PrimitiveMap.SHORT_TYPE)
	{
	return this.dataIn.ReadInt16().ToString();
	}
	else if(type == PrimitiveMap.FLOAT_TYPE)
	{
	return this.dataIn.ReadSingle().ToString();
	}
	else if(type == PrimitiveMap.DOUBLE_TYPE)
	{
	return this.dataIn.ReadDouble().ToString();
	}
	else if(type == PrimitiveMap.CHAR_TYPE)
	{
	return this.dataIn.ReadChar().ToString();
	}
	else if(type == PrimitiveMap.BYTE_TYPE)
	{
	return this.dataIn.ReadByte().ToString();
	}
	else if(type == PrimitiveMap.BOOLEAN_TYPE)
	{
	return this.dataIn.ReadBoolean().ToString();
	}
	else if(type == PrimitiveMap.NULL)
	{
	return null;
	}
	else
	{
	this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
	throw new MessageFormatException("Value is not a known type.");
	}
	}
	catch(FormatException e)
	{
	this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
	throw NMSExceptionSupport.CreateMessageFormatException(e);
	}
	catch(EndOfStreamException e)
	{
	throw NMSExceptionSupport.CreateMessageEOFException(e);
	}
	catch(IOException e)
	{
	throw NMSExceptionSupport.CreateMessageFormatException(e);
	}
	}

	public int ReadBytes(byte[] value)
	{
	InitializeReading();

	if(value == null)
	{
	throw new NullReferenceException("Passed Byte Array is null");
	}

	try
	{
	if(this.bytesRemaining == -1)
	{
	long startingPos = this.byteBuffer.Position;
	byte type = this.dataIn.ReadByte();

	if(type != PrimitiveMap.BYTE_ARRAY_TYPE)
	{
	this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
	throw new MessageFormatException("Not a byte array");
	}

	this.bytesRemaining = this.dataIn.ReadInt32();
	}
	else if(this.bytesRemaining == 0)
	{
	this.bytesRemaining = -1;
	return -1;
	}

	if(value.Length <= this.bytesRemaining)
	{
	// small buffer
	this.bytesRemaining -= value.Length;
	this.dataIn.Read(value, 0, value.Length);
	return value.Length;
	}
	else
	{
	// big buffer
	int rc = this.dataIn.Read(value, 0, this.bytesRemaining);
	this.bytesRemaining = 0;
	return rc;
	}
	}
	catch(EndOfStreamException ex)
	{
	throw NMSExceptionSupport.CreateMessageEOFException(ex);
	}
	catch(IOException ex)
	{
	throw NMSExceptionSupport.CreateMessageFormatException(ex);
	}
	}

	public Object ReadObject()
	{
	InitializeReading();

	long startingPos = this.byteBuffer.Position;

	try
	{
	int type = this.dataIn.ReadByte();

	if(type == PrimitiveMap.BIG_STRING_TYPE)
	{
	return this.dataIn.ReadString32();
	}
	else if(type == PrimitiveMap.STRING_TYPE)
	{
	return this.dataIn.ReadString16();
	}
	else if(type == PrimitiveMap.LONG_TYPE)
	{
	return this.dataIn.ReadInt64();
	}
	else if(type == PrimitiveMap.INTEGER_TYPE)
	{
	return this.dataIn.ReadInt32();
	}
	else if(type == PrimitiveMap.SHORT_TYPE)
	{
	return this.dataIn.ReadInt16();
	}
	else if(type == PrimitiveMap.FLOAT_TYPE)
	{
	return this.dataIn.ReadSingle();
	}
	else if(type == PrimitiveMap.DOUBLE_TYPE)
	{
	return this.dataIn.ReadDouble();
	}
	else if(type == PrimitiveMap.CHAR_TYPE)
	{
	return this.dataIn.ReadChar();
	}
	else if(type == PrimitiveMap.BYTE_TYPE)
	{
	return this.dataIn.ReadByte();
	}
	else if(type == PrimitiveMap.BOOLEAN_TYPE)
	{
	return this.dataIn.ReadBoolean();
	}
	else if(type == PrimitiveMap.BYTE_ARRAY_TYPE)
	{
	int length = this.dataIn.ReadInt32();
	byte[] data = new byte[length];
	this.dataIn.Read(data, 0, length);
	return data;
	}
	else if(type == PrimitiveMap.NULL)
	{
	return null;
	}
	else
	{
	this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
	throw new MessageFormatException("Value is not a known type.");
	}
	}
	catch(FormatException e)
	{
	this.byteBuffer.Seek(startingPos, SeekOrigin.Begin);
	throw NMSExceptionSupport.CreateMessageFormatException(e);
	}
	catch(EndOfStreamException e)
	{
	throw NMSExceptionSupport.CreateMessageEOFException(e);
	}
	catch(IOException e)
	{
	throw NMSExceptionSupport.CreateMessageFormatException(e);
	}
	}

	public void WriteBoolean(bool value)
	{
	InitializeWriting();
	try
	{
	this.dataOut.Write(PrimitiveMap.BOOLEAN_TYPE);
	this.dataOut.Write(value);
	}
	catch(IOException e)
	{
	NMSExceptionSupport.Create(e);
	}
	}

	public void WriteByte(byte value)
	{
	InitializeWriting();
	try
	{
	this.dataOut.Write(PrimitiveMap.BYTE_TYPE);
	this.dataOut.Write(value);
	}
	catch(IOException e)
	{
	NMSExceptionSupport.Create(e);
	}
	}

	public void WriteBytes(byte[] value)
	{
	InitializeWriting();
	this.WriteBytes(value, 0, value.Length);
	}

	public void WriteBytes(byte[] value, int offset, int length)
	{
	InitializeWriting();
	try
	{
	this.dataOut.Write(PrimitiveMap.BYTE_ARRAY_TYPE);
	this.dataOut.Write((int) length);
	this.dataOut.Write(value, offset, length);
	}
	catch(IOException e)
	{
	NMSExceptionSupport.Create(e);
	}
	}

	public void WriteChar(char value)
	{
	InitializeWriting();
	try
	{
	this.dataOut.Write(PrimitiveMap.CHAR_TYPE);
	this.dataOut.Write(value);
	}
	catch(IOException e)
	{
	NMSExceptionSupport.Create(e);
	}
	}

	public void WriteInt16(short value)
	{
	InitializeWriting();
	try
	{
	this.dataOut.Write(PrimitiveMap.SHORT_TYPE);
	this.dataOut.Write(value);
	}
	catch(IOException e)
	{
	NMSExceptionSupport.Create(e);
	}
	}

	public void WriteInt32(int value)
	{
	InitializeWriting();
	try
	{
	this.dataOut.Write(PrimitiveMap.INTEGER_TYPE);
	this.dataOut.Write(value);
	}
	catch(IOException e)
	{
	NMSExceptionSupport.Create(e);
	}
	}

	public void WriteInt64(long value)
	{
	InitializeWriting();
	try
	{
	this.dataOut.Write(PrimitiveMap.LONG_TYPE);
	this.dataOut.Write(value);
	}
	catch(IOException e)
	{
	NMSExceptionSupport.Create(e);
	}
	}

	public void WriteSingle(float value)
	{
	InitializeWriting();
	try
	{
	this.dataOut.Write(PrimitiveMap.FLOAT_TYPE);
	this.dataOut.Write(value);
	}
	catch(IOException e)
	{
	NMSExceptionSupport.Create(e);
	}
	}

	public void WriteDouble(double value)
	{
	InitializeWriting();
	try
	{
	this.dataOut.Write(PrimitiveMap.DOUBLE_TYPE);
	this.dataOut.Write(value);
	}
	catch(IOException e)
	{
	NMSExceptionSupport.Create(e);
	}
	}

	public void WriteString(string value)
	{
	InitializeWriting();
	try
	{
	if( value.Length > 8192 )
	{
	this.dataOut.Write(PrimitiveMap.BIG_STRING_TYPE);
	this.dataOut.WriteString32(value);
	}
	else
	{
	this.dataOut.Write(PrimitiveMap.STRING_TYPE);
	this.dataOut.WriteString16(value);
	}
	}
	catch(IOException e)
	{
	NMSExceptionSupport.Create(e);
	}
	}

	public void WriteObject(Object value)
	{
	InitializeWriting();
	if( value is System.Byte )
	{
	this.WriteByte( (byte) value );
	}
	else if( value is Char )
	{
	this.WriteChar( (char) value );
	}
	else if( value is Boolean )
	{
	this.WriteBoolean( (bool) value );
	}
	else if( value is Int16 )
	{
	this.WriteInt16( (short) value );
	}
	else if( value is Int32 )
	{
	this.WriteInt32( (int) value );
	}
	else if( value is Int64 )
	{
	this.WriteInt64( (long) value );
	}
	else if( value is Single )
	{
	this.WriteSingle( (float) value );
	}
	else if( value is Double )
	{
	this.WriteDouble( (double) value );
	}
	else if( value is byte[] )
	{
	this.WriteBytes( (byte[]) value );
	}
	else if( value is String )
	{
	this.WriteString( (string) value );
	}
	else
	{
	throw new MessageFormatException("Cannot write non-primitive type:" + value.GetType());
	}
	}

	public override Object Clone()
	{
	StoreContent();
	return base.Clone();
	}

	public override void ClearBody()
	{
	base.ClearBody();
	this.byteBuffer = null;
	this.dataIn = null;
	this.dataOut = null;
	this.bytesRemaining = -1;
	}

	public void Reset()
	{
	StoreContent();
	this.dataIn = null;
	this.dataOut = null;
	this.byteBuffer = null;
	this.bytesRemaining = -1;
	this.ReadOnlyBody = true;
	}

	private void InitializeReading()
	{
	FailIfWriteOnlyBody();
	if(this.dataIn == null)
	{
	this.byteBuffer = new MemoryStream(this.Content, false);
	this.dataIn = new EndianBinaryReader(this.byteBuffer);
	}
	}

	private void InitializeWriting()
	{
	FailIfReadOnlyBody();
	if(this.dataOut == null)
	{
	this.byteBuffer = new MemoryStream();
	this.dataOut = new EndianBinaryWriter(this.byteBuffer);
	}
	}

	private void StoreContent()
	{
	if( dataOut != null)
	{
	dataOut.Close();

	this.Content = byteBuffer.ToArray();
	this.dataOut = null;
	this.byteBuffer = null;
	}
	}

	}
	}