public ByteBuffer(byte[] data, Endian endian)
 {
     _data = data;
     _endian = endian;
     _encoding = Encoding.ASCII;
     _specificCharacterSet = null;
 }

			public void ExportNamedConstants( GpuNamedConstants pConsts, string filename, Endian endianMode )
			{
				using ( var f = new FileStream( filename, FileMode.CreateNew, FileAccess.Write ) )
				{
					ExportNamedConstants( pConsts, f, endianMode );
				}
			}

 static private bool NeedConvert(Endian endian)
 {
     if (endian == Endian.LittleEndian)
         return !isLittleEndian;
     else
         return isLittleEndian;
 }

 public static BinaryReader Create(Stream s, Endian e)
 {
     if (BitConverter.IsLittleEndian)
     {
         if (Endian.Little == e)
         {
             return new BinaryReader(s);
         }
         else
         {
             return new EndianBinaryReader(s, e);
         }
     }
     else
     {
         if (Endian.Big == e)
         {
             return new BinaryReader(s);
         }
         else
         {
             return new EndianBinaryReader(s, e);
         }
     }
 }

	/**
	 * Writes any number of bytes into a byte array, at a given position.
	 * This is an aux function used when creating the WAV data.
	 */
	public static void writeBytes(byte[] __bytes, ref int __position, byte[] __newBytes, Endian __endian) {
		// Writes __newBytes to __bytes at position __position, increasing the position depending on the length of __newBytes
		for (int i = 0; i < __newBytes.Length; i++) {
			__bytes[__position] = __newBytes[__endian == Endian.BIG_ENDIAN ? i : __newBytes.Length - i - 1];
			__position++;
		}
	}

        /// <summary>
        /// Initializes a new instance of the DataStream class.  
        /// This will store all PDU information for either an InputStream or OutputStream.
        /// </summary>
        public DataStream()
        {
            // Test the machine to determine to see what it supports.
            this.endianType = (BitConverter.IsLittleEndian ? Endian.Little : Endian.Big);

            // create a new MemoryStream
            this.Stream = new MemoryStream();
        }

 public static void WriteValueF32(this Stream stream, Single value, Endian endian)
 {
     byte[] data = ShouldSwap(endian) == true
                       ? BitConverter.GetBytes(BitConverter.ToInt32(BitConverter.GetBytes(value), 0).Swap())
                       : BitConverter.GetBytes(value);
     Debug.Assert(data.Length == 4);
     stream.WriteBytes(data);
 }

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="endianness">Big or little endian</param>
        /// <param name="sizeofInt">Size of int in bytes</param>
        /// <param name="sizeofSizeT">Size of size_t in bytes</param>
        /// <param name="sizeofLuaNumber">Size of lua_Number in bytes</param>
        /// <param name="stripDebugInfo">Whether to strip debug info or not</param>
	    public LuaCompilerConfig(Endian endianness, int sizeofInt, int sizeofSizeT, int sizeofLuaNumber, bool stripDebugInfo)
	    {
            Endianness = endianness;
            SizeOfInt = sizeofInt;
            SizeOfSizeT = sizeofSizeT;
            SizeOfLuaNumber = sizeofLuaNumber;
            StripDebugInfo = stripDebugInfo;
	    }

		internal FileReference(DicomStreamOpener streamOpener, long offset, long length, Endian endian, DicomVr vr)
		{
			StreamOpener = streamOpener;
			Offset = offset;
			_length = length;
			Endian = endian;
			Vr = vr;
		}

 public static void WriteValueF64(this Stream stream, Double value, Endian endian)
 {
     byte[] data = ShouldSwap(endian) == true
                       ? BitConverter.GetBytes(BitConverter.DoubleToInt64Bits(value).Swap())
                       : BitConverter.GetBytes(value);
     Debug.Assert(data.Length == 8);
     stream.WriteBytes(data);
 }

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="data">Data to encapsulate</param>
        /// <param name="endian"><see cref="Endian"/> to use when reading the data.</param>
        public EndianBinaryReader(byte[] data, Endian endian)
            : base(new MemoryStream(data))
        {
            if (data == null)
                throw new ArgumentNullException("data");

            this.CurrentEndian = endian;
        }

		internal FileReference(string file, long offset, long length, Endian endian, DicomVr vr)
		{
			_filename = file;
			_offset = offset;
			_length = length;
			_endian = endian;
			_vr = vr;
		}

		private ByteBuffer(byte[] data, Endian endian, bool highCapacityMode = false)
		{
			_data = data;
			_endian = endian;
			Encoding = Encoding.ASCII;
			SpecificCharacterSet = null;
			_highCapacityMode = highCapacityMode;
		}

 public static Guid ReadValueGuid(this Stream stream, Endian endian)
 {
     var a = stream.ReadValueS32(endian);
     var b = stream.ReadValueS16(endian);
     var c = stream.ReadValueS16(endian);
     var d = stream.ReadBytes(8);
     return new Guid(a, b, c, d);
 }

 public MPEntryValue(byte[] bytes, int startIndex, Endian endian)
 {
     ImageAttr = (uint)BitConverterEx.ToInt32(bytes, startIndex + 0, endian);
     ImageSize = (uint)BitConverterEx.ToInt32(bytes, startIndex + 4, endian);
     ImageDataOffset = (uint)BitConverterEx.ToInt32(bytes, startIndex + 8, endian);
     DependentImage1 = (ushort)BitConverterEx.ToInt16(bytes, startIndex + 12, endian);
     DependentImage2 = (ushort)BitConverterEx.ToInt16(bytes, startIndex + 14, endian);
 }

        public static bool NeedToSwapBytes(Endian endian)
        {
            if (BitConverter.IsLittleEndian)
            {
                return Endian.Little != endian;
            }

            return Endian.Big != endian;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="EndianStream"/> class.
        /// </summary>
        /// <param name="stream">The stream to read from and write to.</param>
        /// <param name="endianness">The initial endianness to use when operating on the stream.</param>
        /// <exception cref="System.ArgumentException">Thrown if <paramref name="stream"/> is not both readable and writable.</exception>
        public EndianStream(Stream stream, Endian endianness)
        {
            if (!stream.CanRead || !stream.CanWrite)
                throw new ArgumentException("The input stream must be both readable and writable.");

            _stream = stream;
            _reader = new EndianReader(stream, endianness);
            _writer = new EndianWriter(stream, endianness);
        }

 internal static bool ShouldSwap(Endian endian)
 {
     switch (endian)
     {
         case Endian.Little: return BitConverter.IsLittleEndian == false;
         case Endian.Big: return BitConverter.IsLittleEndian == true;
         default: throw new ArgumentException("unsupported endianness", "endian");
     }
 }

 public static void WriteValueGuid(this Stream stream, Guid value, Endian endian)
 {
     var data = value.ToByteArray();
     Debug.Assert(data.Length == 16);
     stream.WriteValueS32(BitConverter.ToInt32(data, 0), endian);
     stream.WriteValueS16(BitConverter.ToInt16(data, 4), endian);
     stream.WriteValueS16(BitConverter.ToInt16(data, 6), endian);
     stream.Write(data, 8, 8);
 }

        /// <summary>
        /// Reads a 4-byte unsigned integer from the current stream using provided endian and advances the
        ///  position of the stream by four bytes.
        /// </summary>
        /// <param name="reader"></param>
        /// <param name="endian">Endian of binary stream.</param>
        /// <returns></returns>
        public static uint ReadUInt32(this BinaryReader reader, Endian endian)
        {
            if(endian == Endian.SmallEndian)
                return reader.ReadUInt32();

            var buffer = new byte[4];
            reader.Read(buffer, 0, 4);

            return BitConverter.ToUInt32(buffer.Reverse().ToArray(), 0);
        }