412 lines
13 KiB
C#
Executable File
412 lines
13 KiB
C#
Executable File
/*
|
|
* Copyright 2014 Google Inc. All rights reserved.
|
|
*
|
|
* Licensed 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.
|
|
*/
|
|
|
|
//#define UNSAFE_BYTEBUFFER // uncomment this line to use faster ByteBuffer
|
|
|
|
using System;
|
|
using System.Linq;
|
|
|
|
namespace FlatBuffers
|
|
{
|
|
/// <summary>
|
|
/// Class to mimic Java's ByteBuffer which is used heavily in Flatbuffers.
|
|
/// If your execution environment allows unsafe code, you should enable
|
|
/// unsafe code in your project and #define UNSAFE_BYTEBUFFER to use a
|
|
/// MUCH faster version of ByteBuffer.
|
|
/// </summary>
|
|
public class ByteBuffer
|
|
{
|
|
private readonly byte[] _buffer;
|
|
private int _pos; // Must track start of the buffer.
|
|
|
|
public int Length { get { return _buffer.Length; } }
|
|
|
|
public byte[] Data { get { return _buffer; } }
|
|
|
|
public ByteBuffer(byte[] buffer)
|
|
{
|
|
_buffer = buffer;
|
|
_pos = 0;
|
|
}
|
|
|
|
public int position() { return _pos; }
|
|
|
|
// Helper functions for the unsafe version.
|
|
static public ushort ReverseBytes(ushort input)
|
|
{
|
|
return (ushort)(((input & 0x00FFU) << 8) |
|
|
((input & 0xFF00U) >> 8));
|
|
}
|
|
static public uint ReverseBytes(uint input)
|
|
{
|
|
return ((input & 0x000000FFU) << 24) |
|
|
((input & 0x0000FF00U) << 8) |
|
|
((input & 0x00FF0000U) >> 8) |
|
|
((input & 0xFF000000U) >> 24);
|
|
}
|
|
static public ulong ReverseBytes(ulong input)
|
|
{
|
|
return (((input & 0x00000000000000FFUL) << 56) |
|
|
((input & 0x000000000000FF00UL) << 40) |
|
|
((input & 0x0000000000FF0000UL) << 24) |
|
|
((input & 0x00000000FF000000UL) << 8) |
|
|
((input & 0x000000FF00000000UL) >> 8) |
|
|
((input & 0x0000FF0000000000UL) >> 24) |
|
|
((input & 0x00FF000000000000UL) >> 40) |
|
|
((input & 0xFF00000000000000UL) >> 56));
|
|
}
|
|
|
|
#if !UNSAFE_BYTEBUFFER
|
|
// Helper functions for the safe (but slower) version.
|
|
protected void WriteLittleEndian(int offset, byte[] data)
|
|
{
|
|
if (!BitConverter.IsLittleEndian)
|
|
{
|
|
Array.Reverse(data, 0, data.Length);
|
|
}
|
|
Buffer.BlockCopy(data, 0, _buffer, offset, data.Length);
|
|
_pos = offset;
|
|
}
|
|
|
|
protected byte[] ReadLittleEndian(int offset, int count)
|
|
{
|
|
AssertOffsetAndLength(offset, count);
|
|
var tmp = new byte[count];
|
|
Buffer.BlockCopy(_buffer, offset, tmp, 0, count);
|
|
return (BitConverter.IsLittleEndian)
|
|
? tmp
|
|
: tmp.Reverse().ToArray();
|
|
}
|
|
#endif // !UNSAFE_BYTEBUFFER
|
|
|
|
private void AssertOffsetAndLength(int offset, int length)
|
|
{
|
|
if (offset < 0 ||
|
|
offset >= _buffer.Length ||
|
|
offset + length > _buffer.Length)
|
|
throw new ArgumentOutOfRangeException();
|
|
}
|
|
|
|
public void PutSbyte(int offset, sbyte value)
|
|
{
|
|
AssertOffsetAndLength(offset, sizeof(sbyte));
|
|
_buffer[offset] = (byte)value;
|
|
_pos = offset;
|
|
}
|
|
|
|
public void PutByte(int offset, byte value)
|
|
{
|
|
AssertOffsetAndLength(offset, sizeof(byte));
|
|
_buffer[offset] = value;
|
|
_pos = offset;
|
|
}
|
|
|
|
#if UNSAFE_BYTEBUFFER
|
|
// Unsafe but more efficient versions of Put*.
|
|
public void PutShort(int offset, short value)
|
|
{
|
|
PutUshort(offset, (ushort)value);
|
|
}
|
|
|
|
public unsafe void PutUshort(int offset, ushort value)
|
|
{
|
|
AssertOffsetAndLength(offset, sizeof(ushort));
|
|
fixed (byte* ptr = _buffer)
|
|
{
|
|
*(ushort*)(ptr + offset) = BitConverter.IsLittleEndian
|
|
? value
|
|
: ReverseBytes(value);
|
|
}
|
|
_pos = offset;
|
|
}
|
|
|
|
public void PutInt(int offset, int value)
|
|
{
|
|
PutUint(offset, (uint)value);
|
|
}
|
|
|
|
public unsafe void PutUint(int offset, uint value)
|
|
{
|
|
AssertOffsetAndLength(offset, sizeof(uint));
|
|
fixed (byte* ptr = _buffer)
|
|
{
|
|
*(uint*)(ptr + offset) = BitConverter.IsLittleEndian
|
|
? value
|
|
: ReverseBytes(value);
|
|
}
|
|
_pos = offset;
|
|
}
|
|
|
|
public unsafe void PutLong(int offset, long value)
|
|
{
|
|
PutUlong(offset, (ulong)value);
|
|
}
|
|
|
|
public unsafe void PutUlong(int offset, ulong value)
|
|
{
|
|
AssertOffsetAndLength(offset, sizeof(ulong));
|
|
|
|
fixed (byte* ptr = _buffer)
|
|
{
|
|
*(ulong*)(ptr + offset) = BitConverter.IsLittleEndian
|
|
? value
|
|
: ReverseBytes(value);
|
|
}
|
|
_pos = offset;
|
|
}
|
|
|
|
public unsafe void PutFloat(int offset, float value)
|
|
{
|
|
AssertOffsetAndLength(offset, sizeof(float));
|
|
fixed (byte* ptr = _buffer)
|
|
{
|
|
if (BitConverter.IsLittleEndian)
|
|
{
|
|
*(float*)(ptr + offset) = value;
|
|
}
|
|
else
|
|
{
|
|
*(uint*)(ptr + offset) = ReverseBytes(*(uint*)(&value));
|
|
}
|
|
}
|
|
_pos = offset;
|
|
}
|
|
|
|
public unsafe void PutDouble(int offset, double value)
|
|
{
|
|
AssertOffsetAndLength(offset, sizeof(double));
|
|
fixed (byte* ptr = _buffer)
|
|
{
|
|
if (BitConverter.IsLittleEndian)
|
|
{
|
|
*(double*)(ptr + offset) = value;
|
|
|
|
}
|
|
else
|
|
{
|
|
*(ulong*)(ptr + offset) = ReverseBytes(*(ulong*)(ptr + offset));
|
|
}
|
|
}
|
|
_pos = offset;
|
|
}
|
|
#else // !UNSAFE_BYTEBUFFER
|
|
// Slower versions of Put* for when unsafe code is not allowed.
|
|
public void PutShort(int offset, short value)
|
|
{
|
|
AssertOffsetAndLength(offset, sizeof(short));
|
|
WriteLittleEndian(offset, BitConverter.GetBytes(value));
|
|
}
|
|
|
|
public void PutUshort(int offset, ushort value)
|
|
{
|
|
AssertOffsetAndLength(offset, sizeof(ushort));
|
|
WriteLittleEndian(offset, BitConverter.GetBytes(value));
|
|
}
|
|
|
|
public void PutInt(int offset, int value)
|
|
{
|
|
AssertOffsetAndLength(offset, sizeof(int));
|
|
WriteLittleEndian(offset, BitConverter.GetBytes(value));
|
|
}
|
|
|
|
public void PutUint(int offset, uint value)
|
|
{
|
|
AssertOffsetAndLength(offset, sizeof(uint));
|
|
WriteLittleEndian(offset, BitConverter.GetBytes(value));
|
|
}
|
|
|
|
public void PutLong(int offset, long value)
|
|
{
|
|
AssertOffsetAndLength(offset, sizeof(long));
|
|
WriteLittleEndian(offset, BitConverter.GetBytes(value));
|
|
}
|
|
|
|
public void PutUlong(int offset, ulong value)
|
|
{
|
|
AssertOffsetAndLength(offset, sizeof(ulong));
|
|
WriteLittleEndian(offset, BitConverter.GetBytes(value));
|
|
}
|
|
|
|
public void PutFloat(int offset, float value)
|
|
{
|
|
AssertOffsetAndLength(offset, sizeof(float));
|
|
WriteLittleEndian(offset, BitConverter.GetBytes(value));
|
|
}
|
|
|
|
public void PutDouble(int offset, double value)
|
|
{
|
|
AssertOffsetAndLength(offset, sizeof(double));
|
|
WriteLittleEndian(offset, BitConverter.GetBytes(value));
|
|
}
|
|
|
|
#endif // UNSAFE_BYTEBUFFER
|
|
|
|
public sbyte GetSbyte(int index)
|
|
{
|
|
AssertOffsetAndLength(index, sizeof(sbyte));
|
|
return (sbyte)_buffer[index];
|
|
}
|
|
|
|
public byte Get(int index)
|
|
{
|
|
AssertOffsetAndLength(index, sizeof(byte));
|
|
return _buffer[index];
|
|
}
|
|
|
|
#if UNSAFE_BYTEBUFFER
|
|
// Unsafe but more efficient versions of Get*.
|
|
public short GetShort(int offset)
|
|
{
|
|
return (short)GetUshort(offset);
|
|
}
|
|
|
|
public unsafe ushort GetUshort(int offset)
|
|
{
|
|
AssertOffsetAndLength(offset, sizeof(ushort));
|
|
fixed (byte* ptr = _buffer)
|
|
{
|
|
return BitConverter.IsLittleEndian
|
|
? *(ushort*)(ptr + offset)
|
|
: ReverseBytes(*(ushort*)(ptr + offset));
|
|
}
|
|
}
|
|
|
|
public int GetInt(int offset)
|
|
{
|
|
return (int)GetUint(offset);
|
|
}
|
|
|
|
public unsafe uint GetUint(int offset)
|
|
{
|
|
AssertOffsetAndLength(offset, sizeof(uint));
|
|
fixed (byte* ptr = _buffer)
|
|
{
|
|
return BitConverter.IsLittleEndian
|
|
? *(uint*)(ptr + offset)
|
|
: ReverseBytes(*(uint*)(ptr + offset));
|
|
}
|
|
}
|
|
|
|
public long GetLong(int offset)
|
|
{
|
|
return (long)GetUlong(offset);
|
|
}
|
|
|
|
public unsafe ulong GetUlong(int offset)
|
|
{
|
|
AssertOffsetAndLength(offset, sizeof(ulong));
|
|
fixed (byte* ptr = _buffer)
|
|
{
|
|
return BitConverter.IsLittleEndian
|
|
? *(ulong*)(ptr + offset)
|
|
: ReverseBytes(*(ulong*)(ptr + offset));
|
|
}
|
|
}
|
|
|
|
public unsafe float GetFloat(int offset)
|
|
{
|
|
AssertOffsetAndLength(offset, sizeof(float));
|
|
fixed (byte* ptr = _buffer)
|
|
{
|
|
if (BitConverter.IsLittleEndian)
|
|
{
|
|
return *(float*)(ptr + offset);
|
|
}
|
|
else
|
|
{
|
|
uint uvalue = ReverseBytes(*(uint*)(ptr + offset));
|
|
return *(float*)(&uvalue);
|
|
}
|
|
}
|
|
}
|
|
|
|
public unsafe double GetDouble(int offset)
|
|
{
|
|
AssertOffsetAndLength(offset, sizeof(double));
|
|
fixed (byte* ptr = _buffer)
|
|
{
|
|
if (BitConverter.IsLittleEndian)
|
|
{
|
|
return *(double*)(ptr + offset);
|
|
}
|
|
else
|
|
{
|
|
ulong uvalue = ReverseBytes(*(ulong*)(ptr + offset));
|
|
return *(double*)(&uvalue);
|
|
}
|
|
}
|
|
}
|
|
#else // !UNSAFE_BYTEBUFFER
|
|
// Slower versions of Get* for when unsafe code is not allowed.
|
|
public short GetShort(int index)
|
|
{
|
|
var tmp = ReadLittleEndian(index, sizeof(short));
|
|
var value = BitConverter.ToInt16(tmp, 0);
|
|
return value;
|
|
}
|
|
|
|
public ushort GetUshort(int index)
|
|
{
|
|
var tmp = ReadLittleEndian(index, sizeof(ushort));
|
|
var value = BitConverter.ToUInt16(tmp, 0);
|
|
return value;
|
|
}
|
|
|
|
public int GetInt(int index)
|
|
{
|
|
var tmp = ReadLittleEndian(index, sizeof(int));
|
|
var value = BitConverter.ToInt32(tmp, 0);
|
|
return value;
|
|
}
|
|
|
|
public uint GetUint(int index)
|
|
{
|
|
var tmp = ReadLittleEndian(index, sizeof(uint));
|
|
var value = BitConverter.ToUInt32(tmp, 0);
|
|
return value;
|
|
}
|
|
|
|
public long GetLong(int index)
|
|
{
|
|
var tmp = ReadLittleEndian(index, sizeof(long));
|
|
var value = BitConverter.ToInt64(tmp, 0);
|
|
return value;
|
|
}
|
|
|
|
public ulong GetUlong(int index)
|
|
{
|
|
var tmp = ReadLittleEndian(index, sizeof(ulong));
|
|
var value = BitConverter.ToUInt64(tmp, 0);
|
|
return value;
|
|
}
|
|
|
|
public float GetFloat(int index)
|
|
{
|
|
var tmp = ReadLittleEndian(index, sizeof(float));
|
|
var value = BitConverter.ToSingle(tmp, 0);
|
|
return value;
|
|
}
|
|
|
|
public double GetDouble(int index)
|
|
{
|
|
var tmp = ReadLittleEndian(index, sizeof(double));
|
|
var value = BitConverter.ToDouble(tmp, 0);
|
|
return value;
|
|
}
|
|
#endif // UNSAFE_BYTEBUFFER
|
|
}
|
|
}
|