Here are the examples of the csharp api System.IO.BinaryReader.ReadSByte() taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.
170 Examples
19
Source : Pack.cs
with Apache License 2.0
from aequabit
with Apache License 2.0
from aequabit
public object[] Deserialize(byte[] data)
{
MemoryStream Stream = new MemoryStream(data);
BinaryReader Reader = new BinaryReader(Stream, Encoding.UTF8);
List<object> Items = new List<object>();
byte Current = 0;
byte Count = Reader.ReadByte();
for (int I = 0; I <= Count - 1; I++)
{
Current = Reader.ReadByte();
switch (Current)
{
case 0:
Items.Add(Reader.ReadBoolean());
break;
case 1:
Items.Add(Reader.ReadByte());
break;
case 2:
Items.Add(Reader.ReadBytes(Reader.ReadInt32()));
break;
case 3:
Items.Add(Reader.ReadChar());
break;
case 4:
Items.Add(Reader.ReadString().ToCharArray());
break;
case 5:
Items.Add(Reader.ReadDecimal());
break;
case 6:
Items.Add(Reader.ReadDouble());
break;
case 7:
Items.Add(Reader.ReadInt32());
break;
case 8:
Items.Add(Reader.ReadInt64());
break;
case 9:
Items.Add(Reader.ReadSByte());
break;
case 10:
Items.Add(Reader.ReadInt16());
break;
case 11:
Items.Add(Reader.ReadSingle());
break;
case 12:
Items.Add(Reader.ReadString());
break;
case 13:
Items.Add(Reader.ReadUInt32());
break;
case 14:
Items.Add(Reader.ReadUInt64());
break;
case 15:
Items.Add(Reader.ReadUInt16());
break;
case 16:
Items.Add(DateTime.FromBinary(Reader.ReadInt64()));
break;
}
}
Reader.Close();
return Items.ToArray();
}
19
Source : Int8Data.cs
with GNU Affero General Public License v3.0
from aianlinb
with GNU Affero General Public License v3.0
from aianlinb
public override void Read(BinaryReader reader) {
Value = reader.ReadSByte();
}
19
Source : LavalinkUtil.cs
with MIT License
from Aiko-IT-Systems
with MIT License
from Aiko-IT-Systems
public static LavalinkTrack DecodeTrack(string track)
{
// https://github.com/sedmelluq/lavaplayer/blob/804cd1038229230052d9b1dee5e6d1741e30e284/main/src/main/java/com/sedmelluq/discord/lavaplayer/player/DefaultAudioPlayerManager.java#L63-L64
const int TRACK_INFO_VERSIONED = 1;
//const int TRACK_INFO_VERSION = 2;
var raw = Convert.FromBase64String(track);
var decoded = new LavalinkTrack
{
TrackString = track
};
using (var ms = new MemoryStream(raw))
using (var br = new JavaBinaryReader(ms))
{
// https://github.com/sedmelluq/lavaplayer/blob/b0c536098c4f92e6d03b00f19221021f8f50b19b/main/src/main/java/com/sedmelluq/discord/lavaplayer/tools/io/MessageInput.java#L37-L39
var messageHeader = br.ReadInt32();
var messageFlags = (int) ((messageHeader & 0xC0000000L) >> 30);
var messageSize = messageHeader & 0x3FFFFFFF;
//if (messageSize != raw.Length)
// Warn($"Size conflict: {messageSize} but was {raw.Length}");
// https://github.com/sedmelluq/lavaplayer/blob/804cd1038229230052d9b1dee5e6d1741e30e284/main/src/main/java/com/sedmelluq/discord/lavaplayer/player/DefaultAudioPlayerManager.java#L268
// java bytes are signed
// https://docs.oracle.com/javase/7/docs/api/java/io/DataInput.html#readByte()
var version = (messageFlags & TRACK_INFO_VERSIONED) != 0 ? (br.ReadSByte() & 0xFF) : 1;
//if (version != TRACK_INFO_VERSION)
// Warn($"Version conflict: Expected {TRACK_INFO_VERSION} but got {version}");
decoded.replacedle = br.ReadJavaUtf8();
decoded.Author = br.ReadJavaUtf8();
decoded._length = br.ReadInt64();
decoded.Identifier = br.ReadJavaUtf8();
decoded.IsStream = br.ReadBoolean();
var uri = br.ReadNullableString();
decoded.Uri = uri != null && version >= 2 ? new Uri(uri) : null;
}
return decoded;
}
19
Source : BsonReader.cs
with MIT License
from akaskela
with MIT License
from akaskela
private BsonType ReadType()
{
MovePosition(1);
return (BsonType)_reader.ReadSByte();
}
19
Source : BufferReader.cs
with GNU General Public License v3.0
from arycama
with GNU General Public License v3.0
from arycama
public sbyte[] ReadSByteArray(int length)
{
var bytes = new sbyte[length];
for(var i = 0; i < length; i++)
bytes[i] = ReadSByte();
return bytes;
}
19
Source : BinaryReaderExtensions.cs
with GNU General Public License v3.0
from arycama
with GNU General Public License v3.0
from arycama
public static sbyte[] ReadSByteArray(this BinaryReader reader, int length)
{
var bytes = new sbyte[length];
for(var i = 0; i < length; i++)
bytes[i] = reader.ReadSByte();
return bytes;
}
19
Source : CriUnpacker.cs
with MIT License
from Azukee
with MIT License
from Azukee
private List<Dictionary<string, object>> DecryptUTF(byte[] chunk)
{
if (Encoding.ASCII.GetString(chunk, 0, UTFMagic.Length) != UTFMagic)
throw new InvalidMagicException();
var chunkSize = (int) ToUInt32(chunk, 4);
using (var ms = new MemoryStream(chunk, 8, chunkSize))
using (var br = new BinaryReader(ms)) {
var rowsOffset = br.ReadInt32BE();
var stringsOffset = br.ReadInt32BE();
var dataOffset = br.ReadInt32BE() + 8;
br.ReadBytes(4);
int columnCount = br.ReadInt16BE();
int rowLength = br.ReadInt16BE();
var rows = br.ReadInt32BE();
var columns = new List<Column>(columnCount);
for (var i = 0; i < columnCount; i++) {
var flags = br.ReadByte();
if (flags == 0) {
br.ReadBytes(3);
flags = br.ReadByte();
}
var nameOffset = stringsOffset + br.ReadInt32BE();
var posBefore = ms.Position;
ms.Seek(nameOffset, SeekOrigin.Begin);
columns.Add(new Column {Flags = (Flags) flags, Name = br.ReadCString()});
ms.Seek(posBefore, SeekOrigin.Begin);
}
//reading rows
var returnTable = new List<Dictionary<string, object>>(rows);
for (var i = 0; i < rows; i++) {
ms.Seek(rowsOffset + i * rowLength, SeekOrigin.Begin);
var row = new Dictionary<string, object>(columnCount);
returnTable.Add(row);
foreach (var column in columns) {
var storageFlag = column.Flags & Flags.StorageMask;
if (Flags.StorageNone == storageFlag || Flags.StorageZero == storageFlag || Flags.StorageConstant == storageFlag)
continue;
switch (column.Flags & Flags.Mask) {
case Flags.Byte:
row[column.Name] = (int) br.ReadByte();
break;
case Flags.SByte:
row[column.Name] = (int) br.ReadSByte();
break;
case Flags.UInt16:
row[column.Name] = (int) br.ReadUInt16BE();
break;
case Flags.Int16:
row[column.Name] = (int) br.ReadInt16BE();
break;
case Flags.UInt32:
case Flags.Int32:
row[column.Name] = br.ReadInt32BE();
break;
case Flags.UInt64:
case Flags.Int64:
row[column.Name] = br.ReadInt64BE();
break;
case Flags.Float32:
row[column.Name] = br.ReadSingleBE();
break;
case Flags.String: {
var posBefore = ms.Position;
var offset = stringsOffset + br.ReadInt32BE();
ms.Seek(offset, SeekOrigin.Begin);
row[column.Name] = br.ReadCString();
ms.Seek(posBefore, SeekOrigin.Begin);
break;
}
case Flags.Data: {
var offset = dataOffset + br.ReadInt32BE();
var length = br.ReadInt32BE();
row[column.Name] = chunk.Skip(offset).Take(length).ToArray();
break;
}
}
}
}
return returnTable;
}
}
19
Source : DBReaderExtensions.cs
with The Unlicense
from BAndysc
with The Unlicense
from BAndysc
public static sbyte[] ReadSByte(this BinaryReader br, int count)
{
var arr = new sbyte[count];
for (var i = 0; i < count; i++)
arr[i] = br.ReadSByte();
return arr;
}
19
Source : DBReader.cs
with The Unlicense
from BAndysc
with The Unlicense
from BAndysc
public void ReadIntoTable(ref DBEntry entry, BinaryReader dbReader, Dictionary<int, string> stringTable)
{
if (entry.Header.RecordCount == 0)
return;
var columnTypes = entry.Data.Columns.Cast<DataColumn>().Select(x => Type.GetTypeCode(x.DataType)).ToArray();
//int[] padding = entry.GetPadding();
var bits = entry.GetBits();
int recordcount = Math.Max(entry.Header.OffsetLengths.Length, (int) entry.Header.RecordCount);
uint recordsize = entry.Header.RecordSize + (uint) (entry.Header.HasIndexTable ? 4 : 0);
if (entry.Header.InternalRecordSize > 0)
recordsize = entry.Header.InternalRecordSize;
entry.Data.BeginLoadData();
for (uint i = 0; i < recordcount; i++)
{
//Offset map has variable record lengths
if (entry.Header.IsTypeOf<HTFX>() || entry.Header.HasOffsetTable)
recordsize = (uint) entry.Header.OffsetLengths[i];
//Store start position
long offset = dbReader.BaseStream.Position;
//Create row and add data
DataRow row = entry.Data.NewRow();
for (var j = 0; j < entry.Data.Columns.Count; j++)
{
if (entry.Data.Columns[j].ExtendedProperties.ContainsKey(AutoGenerated))
{
row.SetField(entry.Data.Columns[j], entry.Data.Rows.Count + 1);
continue;
}
switch (columnTypes[j])
{
case TypeCode.Boolean:
row.SetField(entry.Data.Columns[j], dbReader.ReadBoolean());
break;
case TypeCode.SByte:
row.SetField(entry.Data.Columns[j], dbReader.ReadSByte());
break;
case TypeCode.Byte:
row.SetField(entry.Data.Columns[j], dbReader.ReadByte());
break;
case TypeCode.Int16:
row.SetField(entry.Data.Columns[j], dbReader.ReadInt16());
break;
case TypeCode.UInt16:
row.SetField(entry.Data.Columns[j], dbReader.ReadUInt16());
break;
case TypeCode.Int32:
row.SetField(entry.Data.Columns[j], dbReader.ReadInt32(bits[j]));
break;
case TypeCode.UInt32:
row.SetField(entry.Data.Columns[j], dbReader.ReadUInt32(bits[j]));
break;
case TypeCode.Int64:
row.SetField(entry.Data.Columns[j], dbReader.ReadInt64(bits[j]));
break;
case TypeCode.UInt64:
row.SetField(entry.Data.Columns[j], dbReader.ReadUInt64(bits[j]));
break;
case TypeCode.Single:
row.SetField(entry.Data.Columns[j], dbReader.ReadSingle());
break;
case TypeCode.String:
if (entry.Header.IsTypeOf<WDB>() || entry.Header.IsTypeOf<HTFX>() || entry.Header.HasOffsetTable)
row.SetField(entry.Data.Columns[j], dbReader.ReadStringNull());
else
{
int stindex = entry.Header.GetStringOffset(dbReader, j, i);
if (stringTable.ContainsKey(stindex))
row.SetField(entry.Data.Columns[j], stringTable[stindex]);
else
{
row.SetField(entry.Data.Columns[j], "String not found");
ErrorMessage = "Strings not found in string table";
}
}
break;
default:
throw new Exception($"Unknown field type at column {i}.");
}
//dbReader.BaseStream.Position += padding[j];
}
entry.Data.Rows.Add(row);
//Scrub to the end of the record
if (dbReader.BaseStream.Position - offset < recordsize)
dbReader.BaseStream.Position += recordsize - (dbReader.BaseStream.Position - offset);
else if (dbReader.BaseStream.Position - offset > recordsize)
throw new Exception("Definition exceeds record size");
}
//entry.Header.Clear();
entry.Data.EndLoadData();
}
19
Source : BasePacketReader.cs
with MIT License
from barncastle
with MIT License
from barncastle
public sbyte ReadInt8() => base.ReadSByte();
19
Source : BinaryObjectReader.cs
with MIT License
from BayatGames
with MIT License
from BayatGames
public virtual object Read ( Type type )
{
object result = null;
if ( type == null )
{
result = null;
}
else if ( type.IsPrimitive || type == typeof ( string ) || type == typeof ( decimal ) )
{
if ( type == typeof ( string ) )
{
result = m_Reader.ReadString ();
}
else if ( type == typeof ( decimal ) )
{
result = m_Reader.ReadDecimal ();
}
else if ( type == typeof ( short ) )
{
result = m_Reader.ReadInt16 ();
}
else if ( type == typeof ( int ) )
{
result = m_Reader.ReadInt32 ();
}
else if ( type == typeof ( long ) )
{
result = m_Reader.ReadInt64 ();
}
else if ( type == typeof ( ushort ) )
{
result = m_Reader.ReadUInt16 ();
}
else if ( type == typeof ( uint ) )
{
result = m_Reader.ReadUInt32 ();
}
else if ( type == typeof ( ulong ) )
{
result = m_Reader.ReadUInt64 ();
}
else if ( type == typeof ( double ) )
{
result = m_Reader.ReadDouble ();
}
else if ( type == typeof ( float ) )
{
result = m_Reader.ReadSingle ();
}
else if ( type == typeof ( byte ) )
{
result = m_Reader.ReadByte ();
}
else if ( type == typeof ( sbyte ) )
{
result = m_Reader.ReadSByte ();
}
else if ( type == typeof ( char ) )
{
result = m_Reader.ReadChar ();
}
else if ( type == typeof ( bool ) )
{
result = m_Reader.ReadBoolean ();
}
}
else if ( type.IsEnum )
{
result = Enum.Parse ( type, m_Reader.ReadString () );
}
else if ( type == typeof ( DateTime ) )
{
result = DateTime.FromBinary ( m_Reader.ReadInt64 () );
}
else if ( type == typeof ( TimeSpan ) )
{
result = TimeSpan.Parse ( m_Reader.ReadString () );
}
else if ( type.IsArray )
{
Type elementType = type.GetElementType ();
int rank = m_Reader.ReadInt32 ();
int [] lengths = new int[rank];
for ( int i = 0; i < rank; i++ )
{
lengths [ i ] = m_Reader.ReadInt32 ();
}
Array array = Array.CreateInstance ( elementType, lengths );
int [] indices = new int[rank];
for ( int i = 0; i < rank; i++ )
{
for ( int j = 0; j < lengths [ i ]; j++ )
{
indices [ i ] = j;
array.SetValue ( Read ( elementType ), indices );
}
}
result = array;
}
else if ( type.IsGenericType && type.GetGenericTypeDefinition () == typeof ( KeyValuePair<,> ) )
{
PropertyInfo key = type.GetProperty ( "Key" );
PropertyInfo value = type.GetProperty ( "Value" );
key.SetValue ( result, Read ( key.PropertyType ), BindingFlags.Default, null, null, null );
value.SetValue ( result, Read ( value.PropertyType ), BindingFlags.Default, null, null, null );
}
else if ( type.IsGenericType && type.GetGenericTypeDefinition () == typeof ( List<> ) )
{
Type [] genericArgs = type.GetGenericArguments ();
IList list = ( IList )type.GetConstructor ( Type.EmptyTypes ).Invoke ( null );
int length = m_Reader.ReadInt32 ();
for ( int i = 0; i < length; i++ )
{
list.Add ( Read ( genericArgs [ 0 ] ) );
}
result = list;
}
else if ( type.IsGenericType && type.GetGenericTypeDefinition () == typeof ( Dictionary<,> ) )
{
Type [] genericArgs = type.GetGenericArguments ();
IDictionary dictionary = ( IDictionary )type.GetConstructor ( Type.EmptyTypes ).Invoke ( null );
int length = m_Reader.ReadInt32 ();
for ( int i = 0; i < length; i++ )
{
dictionary.Add ( Read ( genericArgs [ 0 ] ), Read ( genericArgs [ 1 ] ) );
}
result = dictionary;
}
else
{
result = ReadObject ( type );
}
if ( result is IDeserializationCallback )
{
( result as IDeserializationCallback ).OnDeserialization ( this );
}
return result;
}
19
Source : BigEndianBinaryReader.cs
with GNU General Public License v3.0
from Bililive
with GNU General Public License v3.0
from Bililive
public override sbyte ReadSByte() => base.ReadSByte();
19
Source : UserSetAvatarRequestHandler.cs
with GNU Lesser General Public License v2.1
from Blancworks
with GNU Lesser General Public License v2.1
from Blancworks
public async override Task<string> HandleMessage(WebSocketConnection connection, BinaryReader reader)
{
await base.HandleMessage(connection, reader);
Guid id = ReadMinecraftUUIDFromBinaryReader(reader);
bool shouldDelete = reader.ReadSByte() == 1;
if (shouldDelete)
await connection.connectionUser.TryDeleteCurrentAvatar();
await connection.connectionUser.SetCurrentAvatar(id);
return string.Empty;
}
19
Source : WebSocketConnection.cs
with GNU Lesser General Public License v2.1
from Blancworks
with GNU Lesser General Public License v2.1
from Blancworks
public async Task MessageLoop()
{
byte[] messageData = await GetNextMessage();
while (messageData.Length != 0 && socket.CloseStatus != WebSocketCloseStatus.Empty)
{
//Create memory stream and binary reader from message array
using (MemoryStream ms = new MemoryStream(messageData))
{
using (BinaryReader br = new BinaryReader(ms, Encoding.UTF8))
{
int handlerID = br.ReadSByte() - sbyte.MinValue - 1;
//Get the handler by ID
if (messageHandlers.Count > handlerID)
{
MessageHandler handler = messageHandlers[handlerID];
Logger.LogMessage("Handling message with Handler ID:" + handlerID + " and protocol name " + handler.ProtocolName);
try
{
await handler.HandleMessage(this, br);
Logger.LogMessage("Handled.");
}
catch (Exception e)
{
Logger.LogMessage(e.ToString());
}
}
else
{
Logger.LogMessage("No message with Handler ID:" + handlerID);
}
}
}
messageData = await GetNextMessage();
//Check message rate limit.
if (!messageRateLimiter.TryTakePoints(1))
{
SendMessage(new ErrorMessageSender(ErrorMessageSender.MESSAGE_RATE_LIMIT));
continue;
}
}
}
19
Source : SilverlightSerializer.cs
with MIT License
from CalciumFramework
with MIT License
from CalciumFramework
private static object ReadValue(BinaryReader reader, Type tp)
{
if (tp == typeof(string))
{
var retString = reader.ReadString();
return retString == "~~NULL~~"
? null
: retString;
}
if (tp == typeof(bool))
return reader.ReadChar() == 'Y';
if (tp == typeof(decimal))
{
var array = DeserializeObject(reader, typeof(int[])) as int[];
return new Decimal(array);
}
if (tp == typeof(DateTime))
return new DateTime(reader.ReadInt64());
if (tp == typeof(TimeSpan))
return new TimeSpan(reader.ReadInt64());
if (tp == typeof(float))
return reader.ReadSingle();
if (tp == typeof(char))
return reader.ReadChar();
if (tp == typeof(ushort))
return reader.ReadUInt16();
if (tp == typeof(double))
return reader.ReadDouble();
if (tp == typeof(ulong))
return reader.ReadUInt64();
if (tp == typeof(int))
return reader.ReadInt32();
if (tp == typeof(uint))
return reader.ReadUInt32();
if (tp == typeof(byte))
return reader.ReadByte();
if (tp == typeof(long))
return reader.ReadInt64();
if (tp == typeof(short))
return reader.ReadInt16();
if (tp == typeof(sbyte))
return reader.ReadSByte();
if (tp == typeof(Guid))
return new Guid(reader.ReadString());
return reader.ReadInt32();
}
19
Source : wzreader.cs
with BSD 2-Clause "Simplified" License
from chengse66
with BSD 2-Clause "Simplified" License
from chengse66
internal T read<T>() where T : struct
{
if (typeof(sbyte) == typeof(T))
return (T)(object)reader.ReadSByte();
if (typeof(byte) == typeof(T))
return (T)(object)reader.ReadByte();
if (typeof(short) == typeof(T))
return (T)(object)reader.ReadInt16();
if (typeof(ushort) == typeof(T))
return (T)(object)reader.ReadUInt16();
if (typeof(int) == typeof(T))
return (T)(object)reader.ReadInt32();
if (typeof(uint) == typeof(T))
return (T)(object)reader.ReadUInt32();
if (typeof(long) == typeof(T))
return (T)(object)reader.ReadInt64();
if (typeof(ulong) == typeof(T))
return (T)(object)reader.ReadUInt64();
if (typeof(float) == typeof(T))
return (T)(object)reader.ReadSingle();
if (typeof(double) == typeof(T))
return (T)(object)reader.ReadDouble();
return default(T);
}
19
Source : SampleHeaderBuilder.cs
with GNU General Public License v3.0
from ciribob
with GNU General Public License v3.0
from ciribob
public override SampleHeader Read(BinaryReader br)
{
SampleHeader sh = new SampleHeader();
var s = br.ReadBytes(20);
sh.SampleName = ByteEncoding.Instance.GetString(s, 0, s.Length);
sh.Start = br.ReadUInt32();
sh.End = br.ReadUInt32();
sh.StartLoop = br.ReadUInt32();
sh.EndLoop = br.ReadUInt32();
sh.SampleRate = br.ReadUInt32();
sh.OriginalPitch = br.ReadByte();
sh.PitchCorrection = br.ReadSByte();
sh.SampleLink = br.ReadUInt16();
sh.SFSampleLink = (SFSampleLink) br.ReadUInt16();
data.Add(sh);
return sh;
}
19
Source : BinarySByteSerializer.cs
with MIT License
from CityOfZion
with MIT License
from CityOfZion
public object Deserialize(IBinarySerializer deserializer, BinaryReader reader, Type type, BinarySerializerSettings settings = null)
{
return reader.ReadSByte();
}
19
Source : BsonReader.cs
with MIT License
from CragonGame
with MIT License
from CragonGame
private BsonType ReadType()
{
MovePosition(1);
return (BsonType)_reader.ReadSByte();
}
19
Source : BGIFont.cs
with MIT License
from cwensley
with MIT License
from cwensley
public void Load(Stream stream)
{
BinaryReader br = new BinaryReader(stream);
byte b;
do
{
b = br.ReadByte();
} while (b != 0x1a);
// fheader
headerSize = br.ReadUInt16();
byte[] name = br.ReadBytes(4);
fontName = Encoding.ASCII.GetString(name);
fontSize = br.ReadUInt16();
fontMajor = br.ReadByte();
fontMinor = br.ReadByte();
minMajor = br.ReadByte();
minMinor = br.ReadByte();
stream.Position = headerSize;
// header
sig = br.ReadByte();
characterCount = br.ReadInt16();
br.ReadByte(); // unused byte
first = br.ReadByte();
characterOffset = br.ReadInt16();
scanFlag = br.ReadByte();
org_to_cap = br.ReadSByte();
org_to_base = br.ReadSByte();
org_to_dec = br.ReadSByte();
byte[] shortName = br.ReadBytes(4);
shortFontName = Encoding.ASCII.GetString(shortName);
br.ReadByte(); // unused byte
// read offset table
Int16[] fontOffsets = new Int16[256];
for (int i=first; i<first+characterCount; i++)
{
fontOffsets[i] = br.ReadInt16();
}
// read character width table
byte[] charWidths = new byte[256];
for (int i=first; i<first+characterCount; i++)
{
charWidths[i] = br.ReadByte();
}
characters = new BGICharacter[256];
long start = stream.Position;
for (int i=first; i<first+characterCount; i++)
{
stream.Seek(start + fontOffsets[i], SeekOrigin.Begin);
characters[i] = new BGICharacter(this, stream, charWidths[i]);
}
capitalHeight = 40;
baseHeight = 0;
descenderHeight = -7;
BGICharacter bc;
bc = characters[(int)'E'];
if (bc == null) bc = characters[(int)'M'];
if (bc != null)
{
bool isFirst = true;
int min = 0;
int max = 0;
foreach (BGICharacter.Stroke s in bc.Strokes)
{
if (isFirst || max < s.y) max = s.y;
if (isFirst || min > s.y) min = s.y;
isFirst = false;
}
capitalHeight = Math.Abs(max);
baseHeight = Math.Abs(min);
}
lowerCaseHeight = capitalHeight/2;
bc = characters[(int)'q'];
if (bc != null)
{
bool isFirst = true;
int min = 0;
int max = 0;
foreach (BGICharacter.Stroke s in bc.Strokes)
{
if (isFirst || max < s.y) max = s.y;
if (isFirst || min > s.y) min = s.y;
isFirst = false;
}
descenderHeight = Math.Abs(min);
}
bc = characters[(int)'x'];
if (bc != null)
{
bool isFirst = true;
int min = 0;
int max = 0;
foreach (BGICharacter.Stroke s in bc.Strokes)
{
if (isFirst || max < s.y) max = s.y;
if (isFirst || min > s.y) min = s.y;
isFirst = false;
}
lowerCaseHeight = Math.Abs(max);
}
//Console.WriteLine("Font {0}", this);
loaded = true;
}
19
Source : EnumReaderWriter.cs
with MIT License
from CyAScott
with MIT License
from CyAScott
public static object ReadEnum(this BinaryReader reader, Type type = null)
{
var enumType = type ?? reader.ReadType();
var integralType = Enum.GetUnderlyingType(enumType);
object integralValue;
if (integralType == typeof(int))
{
integralValue = reader.ReadInt32();
}
else if (integralType == typeof(byte))
{
integralValue = reader.ReadByte();
}
else if (integralType == typeof(uint))
{
integralValue = reader.ReadUInt32();
}
else if (integralType == typeof(long))
{
integralValue = reader.ReadInt64();
}
else if (integralType == typeof(ulong))
{
integralValue = reader.ReadUInt64();
}
else if (integralType == typeof(sbyte))
{
integralValue = reader.ReadSByte();
}
else if (integralType == typeof(short))
{
integralValue = reader.ReadInt16();
}
else if (integralType == typeof(ushort))
{
integralValue = reader.ReadUInt16();
}
else
{
//this should not be possible based on the limitations of the enum type
throw new InvalidOperationException("Unable to serialize the enum value.");
}
return Enum.ToObject(enumType, integralValue);
}
19
Source : ObjectReaderWriter.cs
with MIT License
from CyAScott
with MIT License
from CyAScott
public static async Task<object> ReadObject(this BinaryReader reader, ObjectType objectType, IResolveProxyIds resolver)
{
switch (objectType)
{
case ObjectType.Array:
return await reader.ReadArray(resolver).ConfigureAwait(false);
case ObjectType.Serializable:
return await reader.ReadSerializable(resolver).ConfigureAwait(false);
case ObjectType.Enum:
return reader.ReadEnum();
case ObjectType.Null:
return null;
case ObjectType.Proxy:
var id = reader.ReadInt64();
return resolver.TryToGetInstance(id, out var instance) ? instance : null;
case ObjectType.Type:
return reader.ReadType();
case ObjectType.DateTime:
return reader.ReadDateTime();
case ObjectType.Guid:
return await reader.ReadGuid().ConfigureAwait(false);
case ObjectType.TimeSpan:
return reader.ReadTimeSpan();
case ObjectType.Byte:
return reader.ReadByte();
case ObjectType.Bytes:
var bytes = new byte[reader.ReadInt32()];
var byteIndex = 0;
while (byteIndex < bytes.Length)
{
byteIndex += await reader.BaseStream.ReadAsync(bytes, byteIndex, bytes.Length - byteIndex).ConfigureAwait(false);
}
return bytes;
case ObjectType.Boolean:
return reader.ReadBoolean();
case ObjectType.Char:
return reader.ReadChar();
case ObjectType.Decimal:
return reader.ReadDecimal();
case ObjectType.Double:
return reader.ReadDouble();
case ObjectType.Float:
return reader.ReadSingle();
case ObjectType.Int:
return reader.ReadInt32();
case ObjectType.Long:
return reader.ReadInt64();
case ObjectType.SByte:
return reader.ReadSByte();
case ObjectType.Short:
return reader.ReadInt16();
case ObjectType.Str:
return reader.ReadString();
case ObjectType.UInt:
return reader.ReadUInt32();
case ObjectType.ULong:
return reader.ReadUInt64();
case ObjectType.UShort:
return reader.ReadUInt16();
default:
throw new ArgumentOutOfRangeException();
}
}
19
Source : ByteBuffer.cs
with GNU General Public License v3.0
from CypherCore
with GNU General Public License v3.0
from CypherCore
public sbyte ReadInt8()
{
ResetBitPos();
return readStream.ReadSByte();
}
19
Source : Wire.cs
with Apache License 2.0
from danielcrenna
with Apache License 2.0
from danielcrenna
private static object ReadValue(this Type type, BinaryReader br, ITypeResolver typeResolver)
{
while (true)
{
readValue:
if (type == null)
throw new NullReferenceException();
if (type == typeof(string))
return br.ReadIsNull() ? default : br.ReadString();
if (type == typeof(bool))
return BuiltIns.ReadBoolean(br);
if (type == typeof(int))
return br.ReadInt32();
if (type == typeof(long))
return br.ReadInt64();
if (type == typeof(float))
return br.ReadSingle();
if (type == typeof(double))
return br.ReadDouble();
if (type == typeof(decimal))
return br.ReadDecimal();
if (type == typeof(short))
return br.ReadInt16();
if (type == typeof(uint))
return br.ReadUInt32();
if (type == typeof(ulong))
return br.ReadUInt64();
if (type == typeof(ushort))
return br.ReadUInt16();
if (type == typeof(byte))
return br.ReadByte();
if (type == typeof(sbyte))
return br.ReadSByte();
if (type == typeof(char))
return br.ReadChar();
if (type == typeof(byte?))
return br.ReadIsNull() ? default : br.ReadByte();
if (type == typeof(sbyte?))
return br.ReadIsNull() ? default : br.ReadSByte();
if (type == typeof(bool?))
return br.ReadIsNull() ? default : br.ReadBoolean();
if (type == typeof(short?))
return br.ReadIsNull() ? default : br.ReadInt16();
if (type == typeof(ushort?))
return br.ReadIsNull() ? default : br.ReadUInt16();
if (type == typeof(int?))
return br.ReadIsNull() ? default : br.ReadInt32();
if (type == typeof(uint?))
return br.ReadIsNull() ? default : br.ReadUInt32();
if (type == typeof(long?))
return br.ReadIsNull() ? default : br.ReadInt64();
if (type == typeof(ulong?))
return br.ReadIsNull() ? default : br.ReadUInt64();
if (type == typeof(float?))
return br.ReadIsNull() ? default : br.ReadSingle();
if (type == typeof(double?))
return br.ReadIsNull() ? default : br.ReadDouble();
if (type == typeof(decimal?))
return br.ReadIsNull() ? default : br.ReadDecimal();
if (type == typeof(char?))
return br.ReadIsNull() ? default : br.ReadChar();
if (type == typeof(char[]))
return br.ReadIsNull() ? null : ReadCharArray(br);
if (type == typeof(byte[]))
return br.ReadIsNull() ? null : ReadByteArray(br);
if (type == typeof(TimeSpan))
return br.ReadTimeSpan();
if (type == typeof(DateTimeOffset))
return br.ReadDateTimeOffset();
if (type == typeof(DateTime))
return br.ReadDateTime(typeResolver);
if (type == typeof(TimeSpan?))
return br.ReadIsNull() ? default : br.ReadTimeSpan();
if (type == typeof(DateTimeOffset?))
return br.ReadIsNull() ? null : br.ReadDateTimeOffset();
if (type == typeof(DateTime?))
return br.ReadIsNull() ? null : ReadDateTime(br, typeResolver);
if (typeof(IDictionary<,>).IsreplacedignableFromGeneric(type))
{
if (br.ReadIsNull())
return null;
var method = ReadTypedDictionaryMethod;
if (method == null)
throw new NullReferenceException();
var genericMethod = method.MakeGenericMethod(type.GenericTypeArguments);
return genericMethod.Invoke(null, new object [] { br, typeResolver });
}
if (typeof(IList<>).IsreplacedignableFromGeneric(type))
return br.ReadIsNull() ? null : br.ReadTypedList(type, typeResolver);
if (typeof(IList).IsreplacedignableFrom(type))
return br.ReadIsNull() ? null : br.ReadList(type, typeResolver);
if (type.IsEnum)
{
type = GetEnumType(type);
goto readValue;
}
if (Nullable.GetUnderlyingType(type) != null)
{
if (!br.ReadIsNull())
{
type = Nullable.GetUnderlyingType(type);
goto readValue;
}
return null;
}
return br.ReadObject(type, typeResolver);
}
}
19
Source : TR2FileReadUtilities.cs
with MIT License
from DanzaG
with MIT License
from DanzaG
public static TRRoomSector ReadRoomSector(BinaryReader reader)
{
return new TRRoomSector
{
FDIndex = reader.ReadUInt16(),
BoxIndex = reader.ReadUInt16(),
RoomBelow = reader.ReadByte(),
Floor = reader.ReadSByte(),
RoomAbove = reader.ReadByte(),
Ceiling = reader.ReadSByte()
};
}
19
Source : ResourcesFile.cs
with MIT License
from deepakkumar1984
with MIT License
from deepakkumar1984
private object LoadObjectV1(int dataOffset)
{
Debug.replacedert(System.Threading.Monitor.IsEntered(reader));
reader.Seek(dataSectionPosition + dataOffset, SeekOrigin.Begin);
int typeIndex = reader.Read7BitEncodedInt();
if (typeIndex == -1)
return null;
string typeName = FindType(typeIndex);
int comma = typeName.IndexOf(',');
if (comma > 0) {
// strip replacedembly name
typeName = typeName.Substring(0, comma);
}
switch (typeName) {
case "System.String":
return reader.ReadString();
case "System.Byte":
return reader.ReadByte();
case "System.SByte":
return reader.ReadSByte();
case "System.Int16":
return reader.ReadInt16();
case "System.UInt16":
return reader.ReadUInt16();
case "System.Int32":
return reader.ReadInt32();
case "System.UInt32":
return reader.ReadUInt32();
case "System.Int64":
return reader.ReadInt64();
case "System.UInt64":
return reader.ReadUInt64();
case "System.Single":
return reader.ReadSingle();
case "System.Double":
return reader.ReadDouble();
case "System.DateTime":
// Ideally we should use DateTime's ToBinary & FromBinary,
// but we can't for compatibility reasons.
return new DateTime(reader.ReadInt64());
case "System.TimeSpan":
return new TimeSpan(reader.ReadInt64());
case "System.Decimal":
int[] bits = new int[4];
for (int i = 0; i < bits.Length; i++)
bits[i] = reader.ReadInt32();
return new decimal(bits);
default:
return new ResourceSerializedObject(FindType(typeIndex), this, reader.BaseStream.Position);
}
}
19
Source : ResourcesFile.cs
with MIT License
from deepakkumar1984
with MIT License
from deepakkumar1984
private object LoadObjectV2(int dataOffset)
{
Debug.replacedert(System.Threading.Monitor.IsEntered(reader));
reader.Seek(dataSectionPosition + dataOffset, SeekOrigin.Begin);
var typeCode = (ResourceTypeCode)reader.Read7BitEncodedInt();
switch (typeCode) {
case ResourceTypeCode.Null:
return null;
case ResourceTypeCode.String:
return reader.ReadString();
case ResourceTypeCode.Boolean:
return reader.ReadBoolean();
case ResourceTypeCode.Char:
return (char)reader.ReadUInt16();
case ResourceTypeCode.Byte:
return reader.ReadByte();
case ResourceTypeCode.SByte:
return reader.ReadSByte();
case ResourceTypeCode.Int16:
return reader.ReadInt16();
case ResourceTypeCode.UInt16:
return reader.ReadUInt16();
case ResourceTypeCode.Int32:
return reader.ReadInt32();
case ResourceTypeCode.UInt32:
return reader.ReadUInt32();
case ResourceTypeCode.Int64:
return reader.ReadInt64();
case ResourceTypeCode.UInt64:
return reader.ReadUInt64();
case ResourceTypeCode.Single:
return reader.ReadSingle();
case ResourceTypeCode.Double:
return reader.ReadDouble();
case ResourceTypeCode.Decimal:
return reader.ReadDecimal();
case ResourceTypeCode.DateTime:
// Use DateTime's ToBinary & FromBinary.
long data = reader.ReadInt64();
return DateTime.FromBinary(data);
case ResourceTypeCode.TimeSpan:
long ticks = reader.ReadInt64();
return new TimeSpan(ticks);
// Special types
case ResourceTypeCode.ByteArray: {
int len = reader.ReadInt32();
if (len < 0) {
throw new BadImageFormatException("Resource with negative length");
}
return reader.ReadBytes(len);
}
case ResourceTypeCode.Stream: {
int len = reader.ReadInt32();
if (len < 0) {
throw new BadImageFormatException("Resource with negative length");
}
byte[] bytes = reader.ReadBytes(len);
return new MemoryStream(bytes, writable: false);
}
default:
if (typeCode < ResourceTypeCode.StartOfUserTypes) {
throw new BadImageFormatException("Invalid typeCode");
}
return new ResourceSerializedObject(FindType(typeCode - ResourceTypeCode.StartOfUserTypes), this, reader.BaseStream.Position);
}
}
19
Source : NDArray.cs
with Apache License 2.0
from deepakkumar1984
with Apache License 2.0
from deepakkumar1984
public static NDArrayList LoadNpz(string file)
{
NDArrayList result = new NDArrayList();
using (ZipArchive zip = ZipFile.OpenRead(file))
{
foreach (ZipArchiveEntry entry in zip.Entries)
{
Stream fs = entry.Open();
BinaryReader reader = new BinaryReader(fs);
var magic = reader.ReadChars(6);
var maj = reader.ReadByte();
var min = reader.ReadByte();
int headerLength = reader.ReadUInt16();
string header = new string(reader.ReadChars(headerLength)).Trim();
string mark = "'descr': '";
int s = header.IndexOf(mark) + mark.Length;
int e = header.IndexOf("'", s + 1);
string type = header.Substring(s, e - s);
DType dtype = GetNpyType(type);
mark = "'fortran_order': ";
s = header.IndexOf(mark) + mark.Length;
e = header.IndexOf(",", s + 1);
bool fortran = bool.Parse(header.Substring(s, e - s));
if (fortran)
throw new Exception();
mark = "'shape': (";
s = header.IndexOf(mark) + mark.Length;
e = header.IndexOf(")", s + 1);
var shapeSplit = header.Substring(s, e - s).Split(',');
List<int> shapeInt = new List<int>();
foreach (var element in shapeSplit)
{
if (!string.IsNullOrWhiteSpace(element))
{
shapeInt.Add(Convert.ToInt32(element));
}
}
Shape shape = new Shape(shapeInt);
if (dtype == DType.Int32)
{
List<int> data = new List<int>();
for (int i = 0; i < shape.Size; i++)
{
data.Add(reader.ReadInt32());
}
var x = nd.Array(data.ToArray()).AsType(dtype).Reshape(shape);
result.Add(x);
}
else if (dtype == DType.Int8)
{
List<sbyte> data = new List<sbyte>();
for (int i = 0; i < shape.Size; i++)
{
data.Add(reader.ReadSByte());
}
var x = nd.Array(data.ToArray()).AsType(dtype).Reshape(shape);
result.Add(x);
}
else if (dtype == DType.Int64)
{
List<long> data = new List<long>();
for (int i = 0; i < shape.Size; i++)
{
data.Add(reader.ReadSByte());
}
var x = nd.Array(data.ToArray()).AsType(dtype).Reshape(shape);
result.Add(x);
}
else if (dtype == DType.Float32)
{
List<float> data = new List<float>();
for (int i = 0; i < shape.Size; i++)
{
data.Add(reader.ReadSByte());
}
var x = nd.Array(data.ToArray()).AsType(dtype).Reshape(shape);
result.Add(x);
}
else if (dtype == DType.Float64)
{
List<double> data = new List<double>();
for (int i = 0; i < shape.Size; i++)
{
data.Add(reader.ReadSByte());
}
var x = nd.Array(data.Select(i => (float)i).ToArray()).AsType(dtype).Reshape(shape).AsType(dtype);
result.Add(x);
}
else if (dtype == DType.UInt8)
{
var data = reader.ReadBytes(Convert.ToInt32(shape.Size));
var x = nd.Array(data.Select(i => (float)i).ToArray()).Reshape(shape).AsType(dtype);
result.Add(x);
}
}
}
return result;
}
19
Source : BufferStream.cs
with MIT License
from dereksorensen
with MIT License
from dereksorensen
public sbyte GetSByte()
{
return _reader.ReadSByte();
}
19
Source : BinarySerializer.cs
with Apache License 2.0
from deveel
with Apache License 2.0
from deveel
private static object ReadPrimitive(BinaryReader reader, bool isNull, out Type objectType) {
var nullable = reader.ReadBoolean();
var typeCode = (PrimitiveTypeCode) reader.ReadByte();
objectType = SerializerUtil.GetObjectType(typeCode);
if (nullable)
objectType = typeof(Nullable<>).MakeGenericType(objectType);
if (isNull)
return null;
switch (typeCode) {
case PrimitiveTypeCode.Boolean:
return reader.ReadBoolean();
case PrimitiveTypeCode.Byte:
return reader.ReadByte();
case PrimitiveTypeCode.SByte:
return reader.ReadSByte();
case PrimitiveTypeCode.Int16:
return reader.ReadInt16();
case PrimitiveTypeCode.UInt16:
return reader.ReadUInt16();
case PrimitiveTypeCode.Int32:
return reader.ReadInt32();
case PrimitiveTypeCode.UInt32:
return reader.ReadUInt32();
case PrimitiveTypeCode.Int64:
return reader.ReadInt64();
case PrimitiveTypeCode.UInt64:
return reader.ReadUInt64();
case PrimitiveTypeCode.Single:
return reader.ReadSingle();
case PrimitiveTypeCode.Double:
return reader.ReadDouble();
case PrimitiveTypeCode.Char:
return reader.ReadChar();
case PrimitiveTypeCode.String:
return reader.ReadString();
default:
throw new SerializationException();
}
}
19
Source : BinaryReaderWriterExtensions.cs
with MIT License
from diamondo25
with MIT License
from diamondo25
private static string DecodeString(this BinaryReader reader)
{
// unicode/ascii switch
var len = reader.ReadSByte();
if (len == 0) return "";
var unicode = len > 0;
if (unicode) return reader.DecodeStringUnicode(len);
else return reader.DecodeStringASCII(len);
}
19
Source : BinaryReaderWriterExtensions.cs
with MIT License
from diamondo25
with MIT License
from diamondo25
public static int ReadCompressedInt(this BinaryReader reader)
{
var x = reader.ReadSByte();
if (x == -128) return reader.ReadInt32();
return x;
}
19
Source : BinaryReaderWriterExtensions.cs
with MIT License
from diamondo25
with MIT License
from diamondo25
public static long ReadCompressedLong(this BinaryReader reader)
{
var x = reader.ReadSByte();
if (x == -128) return reader.ReadInt64();
return x;
}
19
Source : ArchiveReader.cs
with MIT License
from diamondo25
with MIT License
from diamondo25
private string DecodeString()
{
// unicode/ascii switch
var len = ReadSByte();
if (len == 0) return "";
var unicode = len > 0;
if (unicode) return DecodeStringUnicode(len);
else return DecodeStringASCII(len);
}
19
Source : BinaryReaderExt.cs
with MIT License
from Dnawrkshp
with MIT License
from Dnawrkshp
public static object ReadObject(this BinaryReader reader, Type type)
{
if (type.GetInterface("IStreamSerializer") != null)
{
var result = (IStreamSerializer)Activator.CreateInstance(type);
result.Deserialize(reader);
return result;
}
else if (type.IsEnum)
return reader.ReadObject(type.GetEnumUnderlyingType()); //Enum.Parse(type, type.GetEnumName(reader.ReadObject(type.GetEnumUnderlyingType())));
else if (type == typeof(bool))
return reader.ReadBoolean();
else if (type == typeof(byte))
return reader.ReadByte();
else if (type == typeof(sbyte))
return reader.ReadSByte();
else if (type == typeof(char))
return reader.ReadChar();
else if (type == typeof(short))
return reader.ReadInt16();
else if (type == typeof(ushort))
return reader.ReadUInt16();
else if (type == typeof(int))
return reader.ReadInt32();
else if (type == typeof(uint))
return reader.ReadUInt32();
else if (type == typeof(long))
return reader.ReadInt64();
else if (type == typeof(ulong))
return reader.ReadUInt64();
else if (type == typeof(float))
return reader.ReadSingle();
else if (type == typeof(double))
return reader.ReadDouble();
else if (type == typeof(string))
return reader.ReadString();
return null;
}
19
Source : NbtByte.cs
with MIT License
from dotnetGame
with MIT License
from dotnetGame
public NbtTag Deserialize(BinaryReader br, bool requireName)
{
string name = null;
if (requireName)
{
name = br.ReadTagString();
}
var value = br.ReadSByte();
return new NbtByte(value, name);
}
19
Source : TypeTreeHelper.cs
with GNU General Public License v3.0
from ds5678
with GNU General Public License v3.0
from ds5678
private static void ReadStringValue(StringBuilder sb, List<TypeTreeNode> m_Nodes, BinaryReader reader, ref int i)
{
var m_Node = m_Nodes[i];
var level = m_Node.Level;
var varTypeStr = m_Node.Type;
var varNameStr = m_Node.Name;
object value = null;
var append = true;
var align = m_Node.MetaFlag.IsAlignBytes();
switch (varTypeStr)
{
case "SInt8":
value = reader.ReadSByte();
break;
case "UInt8":
case "char":
value = reader.ReadByte();
break;
case "short":
case "SInt16":
value = reader.ReadInt16();
break;
case "UInt16":
case "unsigned short":
value = reader.ReadUInt16();
break;
case "int":
case "SInt32":
value = reader.ReadInt32();
break;
case "UInt32":
case "unsigned int":
case "Type*":
value = reader.ReadUInt32();
break;
case "long long":
case "SInt64":
value = reader.ReadInt64();
break;
case "UInt64":
case "unsigned long long":
case "FileSize":
value = reader.ReadUInt64();
break;
case "float":
value = reader.ReadSingle();
break;
case "double":
value = reader.ReadDouble();
break;
case "bool":
value = reader.ReadBoolean();
break;
case "string":
append = false;
var str = reader.ReadAlignedString();
sb.AppendFormat("{0}{1} {2} = \"{3}\"\r\n", (new string('\t', level)), varTypeStr, varNameStr, str);
i += 3;
break;
case "map":
{
if ((m_Nodes[i + 1].MetaFlag.IsAlignBytes()))
align = true;
append = false;
sb.AppendFormat("{0}{1} {2}\r\n", (new string('\t', level)), varTypeStr, varNameStr);
sb.AppendFormat("{0}{1} {2}\r\n", (new string('\t', level + 1)), "Array", "Array");
var size = reader.ReadInt32();
sb.AppendFormat("{0}{1} {2} = {3}\r\n", (new string('\t', level + 1)), "int", "size", size);
var map = GetNodes(m_Nodes, i);
i += map.Count - 1;
var first = GetNodes(map, 4);
var next = 4 + first.Count;
var second = GetNodes(map, next);
for (int j = 0; j < size; j++)
{
sb.AppendFormat("{0}[{1}]\r\n", (new string('\t', level + 2)), j);
sb.AppendFormat("{0}{1} {2}\r\n", (new string('\t', level + 2)), "pair", "data");
int tmp1 = 0;
int tmp2 = 0;
ReadStringValue(sb, first, reader, ref tmp1);
ReadStringValue(sb, second, reader, ref tmp2);
}
break;
}
case "TypelessData":
{
append = false;
var size = reader.ReadInt32();
reader.ReadBytes(size);
i += 2;
sb.AppendFormat("{0}{1} {2}\r\n", (new string('\t', level)), varTypeStr, varNameStr);
sb.AppendFormat("{0}{1} {2} = {3}\r\n", (new string('\t', level)), "int", "size", size);
break;
}
default:
{
if (i < m_Nodes.Count - 1 && m_Nodes[i + 1].Type == "Array") //Array
{
if (m_Nodes[i + 1].MetaFlag.IsAlignBytes())
align = true;
append = false;
sb.AppendFormat("{0}{1} {2}\r\n", (new string('\t', level)), varTypeStr, varNameStr);
sb.AppendFormat("{0}{1} {2}\r\n", (new string('\t', level + 1)), "Array", "Array");
var size = reader.ReadInt32();
sb.AppendFormat("{0}{1} {2} = {3}\r\n", (new string('\t', level + 1)), "int", "size", size);
var vector = GetNodes(m_Nodes, i);
i += vector.Count - 1;
for (int j = 0; j < size; j++)
{
sb.AppendFormat("{0}[{1}]\r\n", (new string('\t', level + 2)), j);
int tmp = 3;
ReadStringValue(sb, vector, reader, ref tmp);
}
break;
}
else //Clreplaced
{
append = false;
sb.AppendFormat("{0}{1} {2}\r\n", (new string('\t', level)), varTypeStr, varNameStr);
var @clreplaced = GetNodes(m_Nodes, i);
i += @clreplaced.Count - 1;
for (int j = 1; j < @clreplaced.Count; j++)
{
ReadStringValue(sb, @clreplaced, reader, ref j);
}
break;
}
}
}
if (append)
sb.AppendFormat("{0}{1} {2} = {3}\r\n", (new string('\t', level)), varTypeStr, varNameStr, value);
if (align)
reader.AlignStream();
}
19
Source : TypeTreeHelper.cs
with GNU General Public License v3.0
from ds5678
with GNU General Public License v3.0
from ds5678
private static object ReadValue(List<TypeTreeNode> m_Nodes, BinaryReader reader, ref int i)
{
var m_Node = m_Nodes[i];
var varTypeStr = m_Node.Type;
object value;
var align = (m_Node.MetaFlag.IsAlignBytes());
switch (varTypeStr)
{
case "SInt8":
value = reader.ReadSByte();
break;
case "UInt8":
case "char":
value = reader.ReadByte();
break;
case "short":
case "SInt16":
value = reader.ReadInt16();
break;
case "UInt16":
case "unsigned short":
value = reader.ReadUInt16();
break;
case "int":
case "SInt32":
value = reader.ReadInt32();
break;
case "UInt32":
case "unsigned int":
case "Type*":
value = reader.ReadUInt32();
break;
case "long long":
case "SInt64":
value = reader.ReadInt64();
break;
case "UInt64":
case "unsigned long long":
case "FileSize":
value = reader.ReadUInt64();
break;
case "float":
value = reader.ReadSingle();
break;
case "double":
value = reader.ReadDouble();
break;
case "bool":
value = reader.ReadBoolean();
break;
case "string":
value = reader.ReadAlignedString();
i += 3;
break;
case "map":
{
if (m_Nodes[i + 1].MetaFlag.IsAlignBytes())
align = true;
var map = GetNodes(m_Nodes, i);
i += map.Count - 1;
var first = GetNodes(map, 4);
var next = 4 + first.Count;
var second = GetNodes(map, next);
var size = reader.ReadInt32();
var dic = new List<KeyValuePair<object, object>>(size);
for (int j = 0; j < size; j++)
{
int tmp1 = 0;
int tmp2 = 0;
dic.Add(new KeyValuePair<object, object>(ReadValue(first, reader, ref tmp1), ReadValue(second, reader, ref tmp2)));
}
value = dic;
break;
}
case "TypelessData":
{
var size = reader.ReadInt32();
value = reader.ReadBytes(size);
i += 2;
break;
}
default:
{
if (i < m_Nodes.Count - 1 && m_Nodes[i + 1].Type == "Array") //Array
{
if ((m_Nodes[i + 1].MetaFlag.IsAlignBytes()))
align = true;
var vector = GetNodes(m_Nodes, i);
i += vector.Count - 1;
var size = reader.ReadInt32();
var list = new List<object>(size);
for (int j = 0; j < size; j++)
{
int tmp = 3;
list.Add(ReadValue(vector, reader, ref tmp));
}
value = list;
break;
}
else //Clreplaced
{
var @clreplaced = GetNodes(m_Nodes, i);
i += @clreplaced.Count - 1;
var obj = new OrderedDictionary();
for (int j = 1; j < @clreplaced.Count; j++)
{
var clreplacedmember = @clreplaced[j];
var name = clreplacedmember.Name;
obj[name] = ReadValue(@clreplaced, reader, ref j);
}
value = obj;
break;
}
}
}
if (align)
reader.AlignStream();
return value;
}
19
Source : LitePacketStream.cs
with MIT License
from Eastrall
with MIT License
from Eastrall
private T ReadPrimitive<T>(Type type)
{
object primitiveValue = Type.GetTypeCode(type) switch
{
TypeCode.Byte => _reader.ReadByte(),
TypeCode.SByte => _reader.ReadSByte(),
TypeCode.Boolean => _reader.ReadBoolean(),
TypeCode.Char => _reader.ReadChar(),
TypeCode.Int16 => _reader.ReadInt16(),
TypeCode.UInt16 => _reader.ReadUInt16(),
TypeCode.Int32 => _reader.ReadInt32(),
TypeCode.UInt32 => _reader.ReadUInt32(),
TypeCode.Single => _reader.ReadSingle(),
TypeCode.Double => _reader.ReadDouble(),
TypeCode.Int64 => _reader.ReadInt64(),
TypeCode.UInt64 => _reader.ReadUInt64(),
TypeCode.String => InternalReadString(),
_ => throw new NotImplementedException(),
};
19
Source : SignedByteDataTypeHandler.cs
with MIT License
from elastacloud
with MIT License
from elastacloud
protected override sbyte ReadSingle(BinaryReader reader, Thrift.SchemaElement tse, int length)
{
return reader.ReadSByte();
}
19
Source : BsonReader.cs
with Apache License 2.0
from elastic
with Apache License 2.0
from elastic
private BsonType ReadType()
{
MovePosition(1);
return (BsonType)_reader.ReadSByte();
}
19
Source : Wz_File.cs
with MIT License
from Elem8100
with MIT License
from Elem8100
public int ReadInt32()
{
int s = this.BReader.ReadSByte();
return (s == -128) ? this.BReader.ReadInt32() : s;
}
19
Source : Wz_File.cs
with MIT License
from Elem8100
with MIT License
from Elem8100
public long ReadInt64()
{
int s = this.BReader.ReadSByte();
return (s == -128) ? this.BReader.ReadInt64() : s;
}
19
Source : Wz_File.cs
with MIT License
from Elem8100
with MIT License
from Elem8100
public float ReadSingle()
{
float fl = this.BReader.ReadSByte();
return (fl == -128) ? this.BReader.ReadSingle() : fl;
}
19
Source : Wz_File.cs
with MIT License
from Elem8100
with MIT License
from Elem8100
public unsafe string ReadString()
{
int size = this.BReader.ReadSByte();
string result = null;
if (size < 0)
{
byte mask = 0xAA;
size = (size == -128) ? this.BReader.ReadInt32() : -size;
var buffer = GetStringBuffer(size);
this.fileStream.Read(buffer, 0, size);
this.WzStructure.encryption.keys.Decrypt(buffer, 0, size);
fixed (byte* pData = buffer)
{
for (int i = 0; i < size; i++)
{
pData[i] ^= mask;
unchecked { mask++; }
}
var enc = this.TextEncoding ?? Encoding.Default;
result = enc.GetString(buffer, 0, size);
}
}
else if (size > 0)
{
ushort mask = 0xAAAA;
if (size == 127)
{
size = this.BReader.ReadInt32();
}
var buffer = GetStringBuffer(size * 2);
this.fileStream.Read(buffer, 0, size * 2);
this.WzStructure.encryption.keys.Decrypt(buffer, 0, size * 2);
fixed (byte* pData = buffer)
{
ushort* pChar = (ushort*)pData;
for (int i = 0; i < size; i++)
{
pChar[i] ^= mask;
unchecked { mask++; }
}
result = new string((char*)pChar, 0, size);
}
}
else
{
return string.Empty;
}
//memory optimize
if (result.Length <= 4)
{
for (int i = 0; i < result.Length; i++)
{
if (result[i] >= 0x80)
{
return result;
}
}
return string.Intern(result);
}
else
{
return result;
}
}
19
Source : OleDocument.cs
with GNU General Public License v3.0
from ElevenPaths
with GNU General Public License v3.0
from ElevenPaths
private String GetValueType(Int64 Offset, Int32 Tipo)
{
try
{
this.stream.Seek(Offset, SeekOrigin.Begin);
BinaryReader br = new BinaryReader(this.stream);
switch (Tipo)
{
case Body.Property.PROPERTY_TYPE_VT_VARIANT:
Tipo = br.ReadInt32();
return GetValueType(this.stream.Position, Tipo);
case Body.Property.PROPERTY_TYPE_VT_EMPTY:
return string.Empty;
case Body.Property.PROPERTY_TYPE_VT_NULL:
br.ReadByte();
return string.Empty;
case Body.Property.PROPERTY_TYPE_VT_I1:
return br.ReadSByte().ToString();
case Body.Property.PROPERTY_TYPE_VT_UI1:
return br.ReadByte().ToString();
case Body.Property.PROPERTY_TYPE_VT_I2:
return br.ReadInt16().ToString();
case Body.Property.PROPERTY_TYPE_VT_UI2:
return br.ReadUInt16().ToString();
case Body.Property.PROPERTY_TYPE_VT_I4:
case Body.Property.PROPERTY_TYPE_VT_INT:
return br.ReadInt32().ToString();
case Body.Property.PROPERTY_TYPE_VT_UI4:
case Body.Property.PROPERTY_TYPE_VT_UINT:
return br.ReadUInt32().ToString();
case Body.Property.PROPERTY_TYPE_VT_I8:
return br.ReadInt64().ToString();
case Body.Property.PROPERTY_TYPE_VT_UI8:
return br.ReadUInt64().ToString();
case Body.Property.PROPERTY_TYPE_VT_BOOL:
return br.ReadBoolean().ToString();
case Body.Property.PROPERTY_TYPE_VT_BSTR:
UInt32 SizeUnicode = br.ReadUInt32();
Byte[] BytesUnicode = br.ReadBytes((int)SizeUnicode);
return Encoding.Unicode.GetString(BytesUnicode, 0, (int)SizeUnicode);
case Body.Property.PROPERTY_TYPE_VT_LPSTR:
UInt32 Size = br.ReadUInt32();
if (Size > 0)
return Encoding.Default.GetString(br.ReadBytes((int)Size)).Replace('\0', ' ');
else
return string.Empty;
case Body.Property.PROPERTY_TYPE_VT_LPWSTR:
UInt32 SizeW = br.ReadUInt32();
if (SizeW > 0)
return Encoding.Unicode.GetString(br.ReadBytes((int)SizeW * 2)).Replace('\0', ' ');
else
return string.Empty;
case Body.Property.PROPERTY_TYPE_VT_FILETIME:
Int64 datetime = br.ReadInt64();
return datetime != 0 ? DateTime.FromFileTimeUtc(datetime).ToString() : string.Empty;
case Body.Property.PROPERTY_TYPE_VT_BLOB:
Size = br.ReadUInt32();
if (Size > 0 && Size < 128)
{
String s = Encoding.Default.GetString(br.ReadBytes((int)Size)).Replace('\0', ' ');
for (int i = 0; i < s.Length;)
if (char.IsControl(s[i])) s = s.Remove(i, 1);
else i++;
return s;
}
else
return string.Empty;
default:
return "Ole Property not supported: " + Tipo;
}
}
catch
{
return string.Empty;
}
}
19
Source : TypeTreeHelper.cs
with MIT License
from evandixon
with MIT License
from evandixon
private static void ReadStringValue(StringBuilder sb, List<TypeTreeNode> members, BinaryReader reader, ref int i)
{
var member = members[i];
var level = member.m_Level;
var varTypeStr = member.m_Type;
var varNameStr = member.m_Name;
object value = null;
var append = true;
var align = (member.m_MetaFlag & 0x4000) != 0;
switch (varTypeStr)
{
case "SInt8":
value = reader.ReadSByte();
break;
case "UInt8":
case "char":
value = reader.ReadByte();
break;
case "short":
case "SInt16":
value = reader.ReadInt16();
break;
case "UInt16":
case "unsigned short":
value = reader.ReadUInt16();
break;
case "int":
case "SInt32":
value = reader.ReadInt32();
break;
case "UInt32":
case "unsigned int":
case "Type*":
value = reader.ReadUInt32();
break;
case "long long":
case "SInt64":
value = reader.ReadInt64();
break;
case "UInt64":
case "unsigned long long":
case "FileSize":
value = reader.ReadUInt64();
break;
case "float":
value = reader.ReadSingle();
break;
case "double":
value = reader.ReadDouble();
break;
case "bool":
value = reader.ReadBoolean();
break;
case "string":
append = false;
var str = reader.ReadAlignedString();
sb.AppendFormat("{0}{1} {2} = \"{3}\"\r\n", (new string('\t', level)), varTypeStr, varNameStr, str);
i += 3;
break;
case "map":
{
if ((members[i + 1].m_MetaFlag & 0x4000) != 0)
align = true;
append = false;
sb.AppendFormat("{0}{1} {2}\r\n", (new string('\t', level)), varTypeStr, varNameStr);
sb.AppendFormat("{0}{1} {2}\r\n", (new string('\t', level + 1)), "Array", "Array");
var size = reader.ReadInt32();
sb.AppendFormat("{0}{1} {2} = {3}\r\n", (new string('\t', level + 1)), "int", "size", size);
var map = GetMembers(members, i);
i += map.Count - 1;
var first = GetMembers(map, 4);
var next = 4 + first.Count;
var second = GetMembers(map, next);
for (int j = 0; j < size; j++)
{
sb.AppendFormat("{0}[{1}]\r\n", (new string('\t', level + 2)), j);
sb.AppendFormat("{0}{1} {2}\r\n", (new string('\t', level + 2)), "pair", "data");
int tmp1 = 0;
int tmp2 = 0;
ReadStringValue(sb, first, reader, ref tmp1);
ReadStringValue(sb, second, reader, ref tmp2);
}
break;
}
case "TypelessData":
{
append = false;
var size = reader.ReadInt32();
reader.ReadBytes(size);
i += 2;
sb.AppendFormat("{0}{1} {2}\r\n", (new string('\t', level)), varTypeStr, varNameStr);
sb.AppendFormat("{0}{1} {2} = {3}\r\n", (new string('\t', level)), "int", "size", size);
break;
}
default:
{
if (i < members.Count - 1 && members[i + 1].m_Type == "Array") //Array
{
if ((members[i + 1].m_MetaFlag & 0x4000) != 0)
align = true;
append = false;
sb.AppendFormat("{0}{1} {2}\r\n", (new string('\t', level)), varTypeStr, varNameStr);
sb.AppendFormat("{0}{1} {2}\r\n", (new string('\t', level + 1)), "Array", "Array");
var size = reader.ReadInt32();
sb.AppendFormat("{0}{1} {2} = {3}\r\n", (new string('\t', level + 1)), "int", "size", size);
var vector = GetMembers(members, i);
i += vector.Count - 1;
for (int j = 0; j < size; j++)
{
sb.AppendFormat("{0}[{1}]\r\n", (new string('\t', level + 2)), j);
int tmp = 3;
ReadStringValue(sb, vector, reader, ref tmp);
}
break;
}
else //Clreplaced
{
append = false;
sb.AppendFormat("{0}{1} {2}\r\n", (new string('\t', level)), varTypeStr, varNameStr);
var @clreplaced = GetMembers(members, i);
i += @clreplaced.Count - 1;
for (int j = 1; j < @clreplaced.Count; j++)
{
ReadStringValue(sb, @clreplaced, reader, ref j);
}
break;
}
}
}
if (append)
sb.AppendFormat("{0}{1} {2} = {3}\r\n", (new string('\t', level)), varTypeStr, varNameStr, value);
if (align)
reader.AlignStream();
}
19
Source : TypeTreeHelper.cs
with MIT License
from evandixon
with MIT License
from evandixon
private static object ReadValue(List<TypeTreeNode> members, BinaryReader reader, ref int i)
{
var member = members[i];
var varTypeStr = member.m_Type;
object value;
var align = (member.m_MetaFlag & 0x4000) != 0;
switch (varTypeStr)
{
case "SInt8":
value = reader.ReadSByte();
break;
case "UInt8":
case "char":
value = reader.ReadByte();
break;
case "short":
case "SInt16":
value = reader.ReadInt16();
break;
case "UInt16":
case "unsigned short":
value = reader.ReadUInt16();
break;
case "int":
case "SInt32":
value = reader.ReadInt32();
break;
case "UInt32":
case "unsigned int":
case "Type*":
value = reader.ReadUInt32();
break;
case "long long":
case "SInt64":
value = reader.ReadInt64();
break;
case "UInt64":
case "unsigned long long":
case "FileSize":
value = reader.ReadUInt64();
break;
case "float":
value = reader.ReadSingle();
break;
case "double":
value = reader.ReadDouble();
break;
case "bool":
value = reader.ReadBoolean();
break;
case "string":
value = reader.ReadAlignedString();
i += 3;
break;
case "map":
{
if ((members[i + 1].m_MetaFlag & 0x4000) != 0)
align = true;
var map = GetMembers(members, i);
i += map.Count - 1;
var first = GetMembers(map, 4);
var next = 4 + first.Count;
var second = GetMembers(map, next);
var size = reader.ReadInt32();
var dic = new List<KeyValuePair<object, object>>(size);
for (int j = 0; j < size; j++)
{
int tmp1 = 0;
int tmp2 = 0;
dic.Add(new KeyValuePair<object, object>(ReadValue(first, reader, ref tmp1), ReadValue(second, reader, ref tmp2)));
}
value = dic;
break;
}
case "TypelessData":
{
var size = reader.ReadInt32();
value = reader.ReadBytes(size);
i += 2;
break;
}
default:
{
if (i < members.Count - 1 && members[i + 1].m_Type == "Array") //Array
{
if ((members[i + 1].m_MetaFlag & 0x4000) != 0)
align = true;
var vector = GetMembers(members, i);
i += vector.Count - 1;
var size = reader.ReadInt32();
var list = new List<object>(size);
for (int j = 0; j < size; j++)
{
int tmp = 3;
list.Add(ReadValue(vector, reader, ref tmp));
}
value = list;
break;
}
else //Clreplaced
{
var @clreplaced = GetMembers(members, i);
i += @clreplaced.Count - 1;
var obj = new UType();
for (int j = 1; j < @clreplaced.Count; j++)
{
var clreplacedmember = @clreplaced[j];
var name = clreplacedmember.m_Name;
obj[name] = ReadValue(@clreplaced, reader, ref j);
}
value = obj;
break;
}
}
}
if (align)
reader.AlignStream();
return value;
}
19
Source : BinaryReaderX.cs
with GNU General Public License v3.0
from FanTranslatorsInternational
with GNU General Public License v3.0
from FanTranslatorsInternational
public override sbyte ReadSByte()
{
Reset();
return base.ReadSByte();
}
19
Source : DRTest.cs
with MIT License
from FingerCaster
with MIT License
from FingerCaster
public override bool ParseDataRow(byte[] dataRowBytes, int startIndex, int length, object userData)
{
using (MemoryStream memoryStream = new MemoryStream(dataRowBytes, startIndex, length, false))
{
using (BinaryReader binaryReader = new BinaryReader(memoryStream, Encoding.UTF8))
{
m_Id = binaryReader.Read7BitEncodedInt32();
BoolValue = binaryReader.ReadBoolean();
ByteValue = binaryReader.ReadByte();
CharValue = binaryReader.ReadChar();
Color32Value = binaryReader.ReadColor32();
ColorValue = binaryReader.ReadColor();
DateTimeValue = binaryReader.ReadDateTime();
DecimalValue = binaryReader.ReadDecimal();
DoubleValue = binaryReader.ReadDouble();
FloatValue = binaryReader.ReadSingle();
IntValue = binaryReader.Read7BitEncodedInt32();
LongValue = binaryReader.Read7BitEncodedInt64();
QuaternionValue = binaryReader.ReadQuaternion();
RectValue = binaryReader.ReadRect();
SByteValue = binaryReader.ReadSByte();
ShortValue = binaryReader.ReadInt16();
StringValue = binaryReader.ReadString();
UIntValue = binaryReader.Read7BitEncodedUInt32();
ULongValue = binaryReader.Read7BitEncodedUInt64();
UShortValue = binaryReader.ReadUInt16();
Vector2Value = binaryReader.ReadVector2();
Vector3Value = binaryReader.ReadVector3();
Vector4Value = binaryReader.ReadVector4();
BoolList = binaryReader.ReadBooleanList();
ByteList = binaryReader.ReadByteList();
CharList = binaryReader.ReadCharList();
Color32List = binaryReader.ReadColor32List();
ColorList = binaryReader.ReadColorList();
DateTimeList = binaryReader.ReadDateTimeList();
DecimalList = binaryReader.ReadDecimalList();
DoubleList = binaryReader.ReadDoubleList();
FloatList = binaryReader.ReadSingleList();
IntList = binaryReader.ReadInt32List();
LongList = binaryReader.ReadInt64List();
QuaternionList = binaryReader.ReadQuaternionList();
RectList = binaryReader.ReadRectList();
SByteList = binaryReader.ReadSByteList();
ShortList = binaryReader.ReadInt16List();
StringList = binaryReader.ReadStringList();
UIntList = binaryReader.ReadUInt32List();
ULongList = binaryReader.ReadUInt64List();
UShortList = binaryReader.ReadUInt16List();
Vector2List = binaryReader.ReadVector2List();
Vector3List = binaryReader.ReadVector3List();
Vector4List = binaryReader.ReadVector4List();
BoolArray = binaryReader.ReadBooleanArray();
ByteArray = binaryReader.ReadByteArray();
CharArray = binaryReader.ReadCharArray();
Color32Array = binaryReader.ReadColor32Array();
ColorArray = binaryReader.ReadColorArray();
DateTimeArray = binaryReader.ReadDateTimeArray();
DecimalArray = binaryReader.ReadDecimalArray();
DoubleArray = binaryReader.ReadDoubleArray();
FloatArray = binaryReader.ReadSingleArray();
IntArray = binaryReader.ReadInt32Array();
LongArray = binaryReader.ReadInt64Array();
QuaternionArray = binaryReader.ReadQuaternionArray();
RectArray = binaryReader.ReadRectArray();
SByteArray = binaryReader.ReadSByteArray();
ShortArray = binaryReader.ReadInt16Array();
StringArray = binaryReader.ReadStringArray();
UIntArray = binaryReader.ReadUInt32Array();
ULongArray = binaryReader.ReadUInt64Array();
UShortArray = binaryReader.ReadUInt16Array();
Vector2Array = binaryReader.ReadVector2Array();
Vector3Array = binaryReader.ReadVector3Array();
Vector4Array = binaryReader.ReadVector4Array();
}
}
GeneratePropertyArray();
return true;
}
See More Examples