corrade-vassal – Rev 1
?pathlinks?
/*
* Copyright (c) 2006-2014, openmetaverse.org
* All rights reserved.
*
* - Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
* - Neither the name of the openmetaverse.org nor the names
* of its contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
using System;
using System.IO;
namespace OpenMetaverse.Rendering
{
/// <summary>
/// Binary reader, which is endian aware
/// </summary>
public class EndianAwareBinaryReader : BinaryReader
{
/// What is the format of the source file
public enum SourceFormat
{
BigEndian, //!< The stream is big endian, SPARC, Arm and friends
LittleEndian //!< x86 and friends
}
private byte[] m_a16 = new byte[2]; //!< Temporary storage area for 2 byte values
private byte[] m_a32 = new byte[4]; //!< Temporary storage area for 4 byte values
private byte[] m_a64 = new byte[8]; //!< Temporary storage area for 8 byte values
private readonly bool m_shouldReverseOrder; //!< true if the file is in a different endian format than the system
/// <summary>
/// Construct a reader from a stream
/// </summary>
/// <param name="stream">The stream to read from</param>
public EndianAwareBinaryReader(Stream stream)
: this(stream, SourceFormat.LittleEndian) {}
/// <summary>
/// Construct a reader from a stream
/// </summary>
/// <param name="stream">The stream to read from</param>
/// <param name="format">What is the format of the file, assumes PC and similar architecture</param>
public EndianAwareBinaryReader(Stream stream, SourceFormat format)
: base(stream)
{
if ((format == SourceFormat.BigEndian && BitConverter.IsLittleEndian) ||
(format == SourceFormat.LittleEndian && !BitConverter.IsLittleEndian))
m_shouldReverseOrder = true;
}
/// <summary>
/// Read a 32 bit integer
/// </summary>
/// <returns>A 32 bit integer in the system's endianness</returns>
public override int ReadInt32()
{
m_a32 = base.ReadBytes(4);
if (m_shouldReverseOrder)
Array.Reverse(m_a32);
return BitConverter.ToInt32(m_a32, 0);
}
/// <summary>
/// Read a 16 bit integer
/// </summary>
/// <returns>A 16 bit integer in the system's endianness</returns>
public override Int16 ReadInt16()
{
m_a16 = base.ReadBytes(2);
if (m_shouldReverseOrder)
Array.Reverse(m_a16);
return BitConverter.ToInt16(m_a16, 0);
}
/// <summary>
/// Read a 64 bit integer
/// </summary>
/// <returns>A 64 bit integer in the system's endianness</returns>
public override Int64 ReadInt64()
{
m_a64 = base.ReadBytes(8);
if (m_shouldReverseOrder)
Array.Reverse(m_a64);
return BitConverter.ToInt64(m_a64, 0);
}
/// <summary>
/// Read an unsigned 32 bit integer
/// </summary>
/// <returns>A 32 bit unsigned integer in the system's endianness</returns>
public override UInt32 ReadUInt32()
{
m_a32 = base.ReadBytes(4);
if (m_shouldReverseOrder)
Array.Reverse(m_a32);
return BitConverter.ToUInt32(m_a32, 0);
}
/// <summary>
/// Read a single precision floating point value
/// </summary>
/// <returns>A single precision floating point value in the system's endianness</returns>
public override float ReadSingle()
{
m_a32 = base.ReadBytes(4);
if (m_shouldReverseOrder)
Array.Reverse(m_a32);
return BitConverter.ToSingle(m_a32, 0);
}
/// <summary>
/// Read a double precision floating point value
/// </summary>
/// <returns>A double precision floating point value in the system's endianness</returns>
public override double ReadDouble()
{
m_a64 = base.ReadBytes(8);
if (m_shouldReverseOrder)
Array.Reverse(m_a64);
return BitConverter.ToDouble(m_a64, 0);
}
/// <summary>
/// Read a UTF-8 string
/// </summary>
/// <returns>A standard system string</returns>
public override string ReadString()
{
using (MemoryStream ms = new MemoryStream())
{
byte b = ReadByte();
while (b != 0)
{
ms.WriteByte(b);
b = ReadByte();
}
return System.Text.Encoding.UTF8.GetString(ms.GetBuffer(), 0, (int)ms.Position);
}
}
/// <summary>
/// Read a UTF-8 string
/// </summary>
/// <param name="size">length of string to read</param>
/// <returns>A standard system string</returns>
public string ReadString(int size)
{
byte[] buffer = ReadBytes(size);
return System.Text.Encoding.UTF8.GetString(buffer).Trim();
}
}
}