private void ParseRiff(Stream Stream) { if (Stream.ReadString(4) != "WAVE") throw (new InvalidDataException("Not a RIFF.WAVE File")); while (!Stream.Eof()) { var ChunkType = Stream.ReadString(4); var ChunkSize = new BinaryReader(Stream).ReadUInt32(); var ChunkStream = Stream.ReadStream(ChunkSize); HandleChunkInternal(ChunkType, ChunkStream); } }
public virtual bool LoadFrom(Stream stream) { uint count = stream.ReadUInt(); for (int i = 0; i < count; i++) { var key = stream.ReadString(); var val = stream.ReadString(); KeyValues.Add(key, val); } return true; }
/* Check to see if this is a GIM */ public override bool Check(ref Stream input, string filename) { try { return (input.ReadString(0x0, 12, false) == GraphicHeader.MIG || input.ReadString(0x0, 12, false) == GraphicHeader.GIM); } catch { return false; } }
/* Checks to see if the input stream is a SNT archive */ public override bool Check(ref Stream input, string filename) { try { return ((input.ReadString(0x0, 4) == ArchiveHeader.NSIF && input.ReadString(0x20, 4) == ArchiveHeader.NSTL) || (input.ReadString(0x0, 4) == ArchiveHeader.NUIF && input.ReadString(0x20, 4) == ArchiveHeader.NUTL)); } catch { return false; } }
public static PlainTextExtension Read(Stream stream) { var blockSize = stream.ReadByte(); if (blockSize != BlockSize) { throw new GifException("Plain text extension data format error"); } var result = new PlainTextExtension { TextGridLeftPosition = stream.ReadShort(), TextGridTopPosition = stream.ReadShort(), TextGridWidth = stream.ReadShort(), TextGridHeight = stream.ReadShort(), CharacterCellWidth = (byte) stream.ReadByte(), CharacterCellHeight = (byte) stream.ReadByte(), TextForegroundColorIndex = (byte) stream.ReadByte(), TextBackgroundColorIndex = (byte) stream.ReadByte(), PlainTextData = new List<string>() }; blockSize = stream.ReadByte(); while (blockSize > 0) { var plainTextData = stream.ReadString(blockSize); result.PlainTextData.Add(plainTextData); blockSize = stream.ReadByte(); } return result; }
private void ParseFile(Stream Stream) { if (Stream.ReadString(4) != "RIFF") throw (new InvalidDataException("Not a RIFF File")); var RiffSize = new BinaryReader(Stream).ReadUInt32(); var RiffStream = Stream.ReadStream(RiffSize); ParseRiff(RiffStream); }
public static ForwardedSubscriptionRequest ReadBody(Stream stream) { var clientId = stream.ReadInt32(); var topic = stream.ReadString(); var isAdd = stream.ReadBoolean(); return new ForwardedSubscriptionRequest(clientId, topic, isAdd); }
public static BodyChunk ReadChunk(string RawBody, Stream ResponseStream) { if (RawBody == "0\r\n\r\n") return new BodyChunk("", true); var bodyIndex = RawBody.IndexOf("\r\n"); var chunkLength = int.Parse(RawBody.Remove(bodyIndex), System.Globalization.NumberStyles.HexNumber); var bodyLength = RawBody.Length - bodyIndex + 2; while (bodyLength <= chunkLength) { var resp = ResponseStream.ReadString(8192 * 4); bodyLength += resp.Length; RawBody += resp; } var body = RawBody.Substring(bodyIndex + 2, chunkLength); var end = bodyIndex + 2 + chunkLength; var tail = RawBody.Substring(end); return new BodyChunk(body, tail.Contains("0")); }
/* Get the offsets, lengths, and filenames of all the files */ public override ArchiveFileList GetFileList(ref Stream data) { try { /* Get the number of files */ uint files = data.ReadUInt(0x0); /* Create the array of files now */ ArchiveFileList fileList = new ArchiveFileList(files); /* Now we can get the file offsets, lengths, and filenames */ for (uint i = 0; i < files; i++) { fileList.Entries[i] = new ArchiveFileList.Entry( data.ReadUInt(0x4 + (i * 0x2C)), // Offset data.ReadUInt(0x8 + (i * 0x2C)), // Length data.ReadString(0xC + (i * 0x2C), 36) // Filename ); } return fileList; } catch { return null; } }
public void Deserialize(Stream input) { var magic = input.ReadValueU32(this.LittleEndian); if (magic != 0x54414653) throw new NotSupportedException("Bad magic number"); this.Unknown04 = input.ReadValueU32(this.LittleEndian); this.NumberOfFiles = input.ReadValueU32(this.LittleEndian); var count = input.ReadValueU32(this.LittleEndian); this.Unknown10 = input.ReadValueU32(this.LittleEndian); this.BasePath = input.ReadString(32, true, Encoding.ASCII); this.Entries.Clear(); for (uint i = 0; i < count; i++) { var entry = new Big.EntryV2(); entry.NameHash = input.ReadValueU32(this.LittleEndian); entry.Locale = input.ReadValueU32(this.LittleEndian); entry.Size = input.ReadValueU32(this.LittleEndian); var offset = input.ReadValueU32(this.LittleEndian); entry.Offset = offset & 0xFFFFFF00; entry.File = offset & 0xFF; this.Entries.Add(entry); } }
public void ReadFrom(Stream stream) { int numMaterials = stream.ReadInt32(); Layers = new MyMaterialLayer[numMaterials]; for (int i = 0; i < numMaterials; ++i) { Layers[i] = new MyMaterialLayer(); Layers[i].StartHeight = stream.ReadFloat(); Layers[i].EndHeight = stream.ReadFloat(); Layers[i].StartAngle = stream.ReadFloat(); Layers[i].EndAngle = stream.ReadFloat(); Layers[i].HeightStartDeviation = stream.ReadFloat(); Layers[i].AngleStartDeviation = stream.ReadFloat(); Layers[i].HeightEndDeviation = stream.ReadFloat(); Layers[i].AngleEndDeviation = stream.ReadFloat(); Layers[i].MaterialDefinition = MyDefinitionManager.Static.GetVoxelMaterialDefinition(stream.ReadString()); } int numOreProbabilities = stream.ReadInt32(); OreProbabilities = new MyOreProbability[numOreProbabilities]; for (int i = 0; i < numOreProbabilities; ++i) { OreProbabilities[i] = new MyOreProbability(); OreProbabilities[i].CummulativeProbability = stream.ReadFloat(); OreProbabilities[i].OreName = stream.ReadString(); } OreStartDepth = stream.ReadFloat(); OreEndDepth = stream.ReadFloat(); }
private static string ReadString(Stream input) { var length = input.ReadValueU32(); if (length >= 1024) { throw new InvalidOperationException(); } return input.ReadString(length, true, Encoding.ASCII); }
/* Checks to see if the input stream is a MRG archive */ public override bool Check(ref Stream input, string filename) { try { return (input.ReadString(0x0, 4) == ArchiveHeader.MRG); } catch { return false; } }
public object Deserialize(Stream stream){ int count = (int)ZigZag.DeserializeUInt32 (stream); var types = new TypeMap (); while(count-- != 0) { uint tag = ZigZag.DeserializeUInt32 (stream); var typeName = stream.ReadString (); var type = this.typeNames.GetType (typeName); types.Add(tag, typeName, type); } return types; }
// Check public override bool Check(ref Stream data, string filename) { try { return (data.ReadString(0x0, 4) == "LZ01"); } catch { return false; } }
public Exception Deserialize(Stream source) { if (source == null) throw new ArgumentNullException("source"); Exception exception = null; var flag = source.ReadByte(); var typeAliasUsed = ((flag & 1) != 0); var typeSerializable = ((flag & 2) != 0); Type type; if (typeAliasUsed) { var typeAlias = source.Read32BitEncodedInt(); type = _data.TypeTable.GetType(typeAlias); if (type == null) { exception = new InvalidOperationException( "Cannot resolve type from alias. Alias=" + typeAlias); } } else { var typeName = source.ReadString(); type = TypeUtility.GetType(typeName); if (type == null) { exception = new InvalidOperationException( "Cannot resolve type from name. Name=" + typeName); } } if (exception == null) { exception = (Exception)Activator.CreateInstance(type); if (typeSerializable) { int dataLen = source.Read32BitEncodedInt(); _data.MessageSerializer.Deserialize(source, exception, type, dataLen); } } else { if (typeSerializable) { int dataLen = source.Read32BitEncodedInt(); source.Position = source.Position + dataLen; } } return exception; }
/* Checks to see if the input stream is a PVM archive */ public override bool Check(ref Stream input, string filename) { try { return (input.ReadString(0x0, 4) == ArchiveHeader.PVM); // && //input.ReadByte(input.ReadUInt(0x4) + 17) < 96); } catch { return false; } }
private void LoadGMK_GMDataFile(IList <KeyValuePair <string, GMDataFile> > _list, Stream _s) { _s.ReadInteger(); int num = _s.ReadInteger(); for (int i = 0; i < num; i++) { string key = _s.ReadString(); GMDataFile value = new GMDataFile(this, _s); _list.Add(new KeyValuePair <string, GMDataFile>(key, value)); } }
/****************************************************************************/ public static string LoadResource(this string resName) { using (Stream s = typeof(MainWindow).Assembly.GetManifestResourceStream("JTranEdit.Assets." + resName)) { if (s == null) { throw new InvalidOperationException("Could not find embedded resource"); } return(s.ReadString()); } }
private void LoadGMK_GMExtension(IList <GMExtension> _list, Stream _s) { _s.ReadInteger(); int num = _s.ReadInteger(); for (int i = 0; i < num; i++) { _s.ReadString(); GMExtension item = new GMExtension(this, _s); _list.Add(item); } }
public static string ReadStringU16(this Stream input, ushort maximumLength, Encoding encoding, Endian endian) { var length = input.ReadValueU16(endian); if (length >= maximumLength) { length = maximumLength; length--; } return(input.ReadString(length, true, encoding)); }
static object Reader(Stream stream, DeserializerSession session) { var name = stream.ReadString(session); var owner = stream.ReadObject(session) as Type; var field = owner .GetField(name, BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); return(field); }
// Check to see if the following data is an ACX public override bool Check(ref Stream input, string filename) { try { return (input.ReadString(0x0, 4, false) == ArchiveHeader.ACX && Path.GetExtension(filename).ToLower() == ".acx"); } catch { return false; } }
public EnumMatchingFlags(Stream stream) { switch (stream.ReadNextByte()) { case 1: m_matchMode = (EnumMatchingFlagsMode)stream.ReadNextByte(); m_value = stream.ReadInt32(); m_description = stream.ReadString(); break; default: throw new VersionNotFoundException(); } }
protected static IColumnSpec[] ReadColumnSpecs(int colCount, string keyspace, string table, bool globalTablesSpec, Stream stream) { IColumnSpec[] columnSpecs = new IColumnSpec[colCount]; for (int colIdx = 0; colIdx < colCount; ++colIdx) { string colKeyspace = keyspace; string colTable = table; if (!globalTablesSpec) { colKeyspace = stream.ReadString(); colTable = stream.ReadString(); } string colName = stream.ReadString(); ColumnType colType = (ColumnType)stream.ReadUShort(); string colCustom = null; ColumnType colKeyType = ColumnType.Custom; ColumnType colValueType = ColumnType.Custom; switch (colType) { case ColumnType.Custom: colCustom = stream.ReadString(); break; case ColumnType.List: case ColumnType.Set: colValueType = (ColumnType)stream.ReadUShort(); break; case ColumnType.Map: colKeyType = (ColumnType)stream.ReadUShort(); colValueType = (ColumnType)stream.ReadUShort(); break; } columnSpecs[colIdx] = new ColumnSpec(colIdx, colKeyspace, colTable, colName, colType, colCustom, colKeyType, colValueType); } return(columnSpecs); }
public GMInstance(Stream _stream, bool _gmk) { X = _stream.ReadInteger(); Y = _stream.ReadInteger(); Index = _stream.ReadInteger(); Id = _stream.ReadInteger(); Code = _stream.ReadString(); _stream.ReadBoolean(); ScaleX = 1.0; ScaleY = 1.0; Colour = uint.MaxValue; Rotation = 0.0; }
public void Deserialize(Stream input, Endian endian) { uint length = input.ReadValueU32(endian); if (length > 1024) { throw new FormatException("doubt there is a file with more than 1024 characters in its name"); } this.Name = input.ReadString(length, true, Encoding.ASCII); this.Offset = input.ReadValueU32(endian); this.Size = input.ReadValueU32(endian); }
public override bool LoadFrom(Stream stream) { base.LoadFrom(stream); Attribute.LoadFrom(stream); UnderlyType = stream.ReadString(); uint count = stream.ReadUInt(); for (int i = 0; i < count; i++) { FieldNames.Add(stream.ReadString()); FieldValues.Add(stream.ReadInt()); } return true; }
static object Reader(Stream stream, DeserializerSession session) { var name = stream.ReadString(session); var owner = stream.ReadObject(session) as Type; var arguments = stream.ReadObject(session) as Type[]; var method = owner.GetMethod(name, BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, CallingConventions.Any, arguments, null); return(method); }
/* Checks to see if the input stream is a MRG archive */ public override bool Check(ref Stream input, string filename) { try { return (input.ReadString(0x0, 4) == ArchiveHeader.TEX && input.ReadUInt(0x4) != input.Length && input.ReadUInt(0x4) != input.Length - 4); } catch { return false; } }
public override object Deserialize(Stream stream, Type type) { stream.AssertNotNull(); type.AssertNotNull(); if (!CanHandle(type)) { Warning($"{nameof(StringSerializer)} cannot handle type {type}!"); return(null); } return(stream.ReadString(Encoding)); }
public override void ParseFromStream(Stream Stream, int Length, MinecraftVersion Version) { int protocolVersion = Stream.ReadVarInt(); this.Version = new MinecraftVersion(protocolVersion); ServerAddress = Stream.ReadString(); ServerPort = Stream.ReadUshort(); NextState = (ConnectionState)Stream.ReadVarInt(); if (NextState != ConnectionState.Login && NextState != ConnectionState.Status) { throw new FormatException(); } }
private static void Deserializer_ReadColumnArray(Stream stream, DataColumnCollection columns) { //读入数据列个数,最多255个字段列 int count = stream.ReadByte(); string c_name; while (--count >= 0) { c_name = stream.ReadString(); var colType = GetCodeType((byte)stream.ReadByte()); columns.Add(c_name, colType); } }
public void Deserialize(Stream input, Endian endian) { this.Unknown2 = input.ReadValueU32(endian); this.Unknown3 = input.ReadValueU32(endian); this.Unknown4 = input.ReadValueU32(endian); this.Unknown5 = input.ReadValueU64(endian); this.Creator = input.ReadString((int)input.ReadValueU32(endian), Encoding.UTF8); this.Unknown7 = input.ReadValueU64(endian); this.Author = input.ReadString((int)input.ReadValueU32(endian), Encoding.UTF8); this.Name = input.ReadString((int)input.ReadValueU32(endian), Encoding.UTF8); this.Unknown10 = input.ReadValueU64(endian); this.Unknown11 = new byte[36]; input.Read(this.Unknown11, 0, this.Unknown11.Length); this.Unknown12 = new byte[36]; input.Read(this.Unknown12, 0, this.Unknown12.Length); this.Size = (Size)input.ReadValueU32(endian); this.Players = (Players)input.ReadValueU32(endian); this.Unknown15 = input.ReadValueU32(endian); }
public static object ReadPrimitiveOrStringType(this Stream stream, Type type) { if (type == typeof(Byte)) { return(stream.ReadByte()); } else if (type == typeof(Boolean)) { return(stream.ReadBool()); } else if (type == typeof(short)) { return(stream.ReadInt16()); } else if (type == typeof(ushort)) { return(stream.ReadUInt16()); } else if (type == typeof(int)) { return(stream.ReadInt32()); } else if (type == typeof(uint)) { return(stream.ReadUInt32()); } else if (type == typeof(long)) { return(stream.ReadInt64()); } else if (type == typeof(ulong)) { return(stream.ReadUInt64()); } else if (type == typeof(float)) { return(stream.ReadFloat()); } else if (type == typeof(double)) { return(stream.ReadDouble()); } else if (type == typeof(string)) { return(stream.ReadString()); } else { return(null); } }
public static (TreeEntry entry, bool eof) Read(Stream stream) { try { var data = stream.ReadString(' '); if (string.IsNullOrEmpty(data)) { return(null, false); } data = data.Substring(0, data.Length - 1); var name = stream.ReadString(0); if (string.IsNullOrEmpty(name)) { return(null, false); } name = name.Substring(0, name.Length - 1); var sha = new byte[20]; if (stream.Read(sha, 0, 20) != 20) { return(null, false); } return(new TreeEntry { name = name, Mode = data, Hash = sha.AsShaToCid() }, false); } catch (EndOfStreamException) { return(null, true); } }
internal override void Deserialize(Stream input, Endian endian, ICacheTables tables) { var visibility = (Visibility)input.ReadValueU8(); var unknown88Index = input.ReadValueU32(endian); var unknown88 = tables.GetDefinition <NativeDefinition>(unknown88Index); var unknown20 = input.ReadValueU16(endian); if ((unknown20 & 0x20) != 0) { var somethingLength = input.ReadValueU16(endian); var something = input.ReadString(somethingLength, true, Encoding.UTF8); } var unknown58Count = input.ReadValueU32(endian); var unknown58s = new Tuple <string, string> [unknown58Count]; for (uint i = 0; i < unknown58Count; i++) { var unknown58_0Length = input.ReadValueU16(endian); var unknown58_0 = input.ReadString(unknown58_0Length, true, Encoding.UTF8); var unknown58_1Length = input.ReadValueU16(endian); var unknown58_1 = input.ReadString(unknown58_1Length, true, Encoding.UTF8); unknown58s[i] = new Tuple <string, string>(unknown58_0, unknown58_1); } var unknown38Count = input.ReadValueU32(endian); var unknown38s = new Tuple <string, string> [unknown38Count]; for (uint i = 0; i < unknown38Count; i++) { var unknown38Length = input.ReadValueU16(endian); var unknown38 = input.ReadString(unknown38Length, true, Encoding.UTF8); var unknown28Length = input.ReadValueU16(endian); var unknown28 = input.ReadString(unknown28Length, true, Encoding.UTF8); unknown38s[i] = new Tuple <string, string>(unknown38, unknown28); } }
public static void ReadPOF(this Stream stream, ref POF POF) { if (stream.ReadString(3) == "POF") { POF.Type = byte.Parse(stream.ReadString(1)); int IsX = POF.Type + 2; stream.Seek(-4, SeekOrigin.Current); POF.Header = stream.ReadHeader(); stream.Seek(POF.Offset + POF.Header.Length, 0); POF.Length = stream.ReadInt32(); while (POF.Length + POF.Offset + POF.Header.Length > stream.Position) { int a = stream.ReadByte(); if (a >> 6 == 0) { break; } else if (a >> 6 == 1) { a = a & 0x3F; } else if (a >> 6 == 2) { a = a & 0x3F; a = (a << 8) | stream.ReadByte(); } else if (a >> 6 == 3) { a = a & 0x3F; a = (a << 8) | stream.ReadByte(); a = (a << 8) | stream.ReadByte(); a = (a << 8) | stream.ReadByte(); } a <<= IsX; POF.LastOffset += a; } } }
// Check public static bool Check(ref Stream data, string filename) { try { // Because this can conflict with other compression formats we are going to add a check them too return(data.ReadString(0x0, 1) == "\x10"); //&& //!Compression.Dictionary[CompressionFormat.PRS].Check(ref data, filename) && //!Images.Dictionary[GraphicFormat.PVR].Check(ref data, filename)); } catch { return(false); } }
public void Deserialize(IBlock parent, Stream input, Endian endian) { var count = input.ReadValueU32(endian); this.Unknown00 = input.ReadValueU32(endian); this.Paths.Clear(); for (uint i = 0; i < count; i++) { var length = input.ReadValueU32(endian); this.Paths.Add(input.ReadString((int)length)); input.Seek(1, SeekOrigin.Current); // skip null } }
public void Read(Stream data) { string str = data.ReadString(size: 4); if (str != TypeStr) { throw new InvalidDataException("Incorrect header chunk type string found"); } Length = data.ReadUInt32BE(); Format = data.ReadUInt16BE(); TrackCount = data.ReadUInt16BE(); rawDivision = data.ReadUInt16BE(); }
/// <summary> /// /// </summary> /// <exception cref="NotImplementedException"></exception> public void ReadRecord() { Debug.Assert(_stream.ReadStringz(2) == "PK"); var structType = _binaryReader.ReadUint16Endian(Endianness.BigEndian); switch (structType) { /* * // F. Central directory structure: * case 0x0102: * break; */ // A. Local file header: case 0x0304: { var localFileHeader = _stream.ReadStruct <LocalFileHeader>(); _stream.Skip(localFileHeader.ExtraFieldLength); var name = _stream.ReadString(localFileHeader.FileNameLength, Encoding.UTF8); var compressedStream = _stream.ReadStream(localFileHeader.CompressedSize); var extraFieldStream = _stream.ReadStream(localFileHeader.ExtraFieldLength); Files.Add(name, new File { ZipArchive = this, LocalFileHeader = localFileHeader, Name = name, CompressedStream = compressedStream, ExtraFieldStream = extraFieldStream }); } break; /* * // I. End of central directory record: * case 0x0506: * break; * // G. Zip64 end of central directory record * case 0x0606: * break; * // H. Zip64 end of central directory locator * case 0x0607: * break; * // E. Archive extra data record: * case 0x0608: * break; */ default: throw new NotImplementedException($"Unknown {structType:X}"); } }
private string FindString(Stream LCPCFile, long ValuesOffset) { byte[] Read = new byte[4]; LCPCFile.Read(Read, 0, 4); Array.Reverse(Read); long Valueoffset = BitConverter.ToInt32(Read, 0); long currentpos = LCPCFile.Position; LCPCFile.Seek(ValuesOffset + Valueoffset, SeekOrigin.Begin); string value = LCPCFile.ReadString(); LCPCFile.Position = currentpos; return(value); }
/// <summary> /// Derializes an <see cref="Material"/> from a stream. /// </summary> /// <param name="stream">The stream to read from.</param> /// <returns>A new instance of <see cref="Material"/> with data read from the <paramref name="stream"/>.</returns> public static Material ReadMaterial(this Stream stream) { var name = stream.ReadString(); MaterialRaw raw = stream.ReadStructure <MaterialRaw>(); var properties = new MaterialProperty[raw.PropertiesCount]; for (uint i = 0; i < raw.PropertiesCount; i++) { properties[i] = stream.ReadMaterialProperty(); } return(new Material(name, properties)); }
// Check public override bool Check(ref Stream data, string filename) { try { // Because this can conflict with other compression formats we are going to add a check them too return (data.ReadString(0x0, 1) == "\x11" && !Compression.Dictionary[CompressionFormat.PRS].Check(ref data, filename) && !Images.Dictionary[GraphicFormat.PVR].Check(ref data, filename)); } catch { return false; } }
public static string ReadStringU32(this Stream stream, Endian endian) { var size = stream.ReadValueU32(endian); if (size == 0) { return(""); } #warning this is an hacked functions by G1zm0! int _sizeHacked = Convert.ToInt32(size); return(stream.ReadString(_sizeHacked, true, Encoding.ASCII)); }
public static string ReadStringPascal(this Stream stream, int maxLength) { var length = stream.ReadValueU16(); if (length > maxLength) { throw new FormatException("string length exceeds maximum length"); } var text = stream.ReadString(length, Encoding.UTF8); var padding = (-(length - 2)) & 3; stream.Seek(padding, SeekOrigin.Current); return(text); }
public static AttrDefItem ParseSingle(Stream stream) { AttrDefItem item = new AttrDefItem(); item.Label = stream.ReadString(Encoding.Unicode, 128); item.Type = stream.ReadUint(); item.DisplayRule = stream.ReadUint(); item.CollationRule = (AttrDefCollationRule)stream.ReadInt(); item.Flags = (AttrDefType)stream.ReadInt(); item.MinimumSize = stream.ReadUlong(); item.MaximumSize = stream.ReadUlong(); return(item); }
public static Dictionary <string, string[]> ReadStringMultimap(this Stream stream) { ushort len = stream.ReadUShort(); Dictionary <string, string[]> data = new Dictionary <string, string[]>(len); for (int i = 0; i < len; ++i) { string key = stream.ReadString(); string[] value = stream.ReadStringList(); data.Add(key, value); } return(data); }
public StringMatching(Stream stream) { switch (stream.ReadNextByte()) { case 1: MatchMode = (StringMatchingMode)stream.ReadNextByte(); MatchText = stream.ReadString(); if (MatchMode == StringMatchingMode.Regex) m_matchRegex = new Regex(MatchText); break; default: throw new VersionNotFoundException(); } }
public void ReadFrom(Stream stream) { int numOreProbabilities = stream.ReadInt32(); OreProbabilities = new MyOreProbability[numOreProbabilities]; for (int i = 0; i < numOreProbabilities; ++i) { OreProbabilities[i] = new MyOreProbability(); OreProbabilities[i].CummulativeProbability = stream.ReadFloat(); OreProbabilities[i].OreName = stream.ReadString(); } OreStartDepth = stream.ReadFloat(); OreEndDepth = stream.ReadFloat(); }
/// <summary> /// Loads a log messages from the supplied stream /// </summary> /// <param name="stream">the stream to load the log message from.</param> /// <param name="helper">the helper to assist in loading/saving</param> internal LogEventPublisherDetails(Stream stream, LogMessageSaveHelper helper) { byte version = stream.ReadNextByte(); switch (version) { case 1: string typeName = stream.ReadString(); string assemblyName = stream.ReadString(); TypeData = new PublisherTypeDefinition(typeName, assemblyName); EventName = stream.ReadString(); break; case 2: EventName = stream.ReadString(); TypeData = helper.LoadPublisherTypeDefinition(stream); break; default: throw new VersionNotFoundException(); } m_hashCode = ComputeHashCode(); }
public void Read(Stream reader) { ParentPath = reader.ReadString(); var extensionPointId = StringHelper.GetExtensionPointId(ParentPath); var childCount = reader.ReadInt32(); _children = new List <ExtensionBuilderRecord>(childCount); for (int i = 0; i < childCount; i++) { var child = ExtensionBuilderRecordHelper.Read(reader, extensionPointId, ParentPath); child.Read(reader); Children.Add(child); } }
public override object ReadValue(Stream stream, DeserializerSession session) { var shortname = stream.ReadString(session); if (shortname == null) return null; var name = TypeEx.ToQualifiedAssemblyName(shortname); var type = Type.GetType(name,true); //add the deserialized type to lookup if (session.Serializer.Options.PreserveObjectReferences) { session.TrackDeserializedObject(type); } return type; }
public CompletedResponse(Stream stream) { string[] tokens = stream.ReadString().Split(); if (tokens.Length > 1) { int rowsAffected; if (int.TryParse(tokens[tokens.Length - 1], out rowsAffected)) _rowsAffected = rowsAffected; else _rowsAffected = null; } _lastInsertedOID = (tokens.Length > 2 && tokens[0].Trim().ToUpperInvariant() == "INSERT") ? long.Parse(tokens[1]) : (long?)null; }
public void Deserialize(Stream input) { var fileAlignment = input.ReadValueU32(true); if (fileAlignment != 0x7FF00000 && fileAlignment != 0x0000F07F && fileAlignment != 0x62300000 && fileAlignment != 0x00003062) { throw new FormatException("unexpected file alignment (should have been 0x7FF00000)"); } this.LittleEndian = fileAlignment == 0x7FF00000 || fileAlignment == 0x62300000; this.FileAlignment = this.LittleEndian == true ? fileAlignment : fileAlignment.Swap(); this.BasePath = input.ReadString(64, true, Encoding.ASCII); var count = input.ReadValueU32(this.LittleEndian); var hashes = new uint[count]; for (uint i = 0; i < count; i++) { hashes[i] = input.ReadValueU32(this.LittleEndian); } this.Entries.Clear(); for (uint i = 0; i < count; i++) { var entry = new Big.Entry(); entry.NameHash = hashes[i]; entry.UncompressedSize = input.ReadValueU32(this.LittleEndian); entry.Offset = input.ReadValueU32(this.LittleEndian); entry.Locale = input.ReadValueU32(this.LittleEndian); entry.CompressedSize = input.ReadValueU32(this.LittleEndian); this.Entries.Add(entry); if (entry.CompressedSize != 0) { throw new NotSupportedException(); } } }
public static MulticastData ReadBody(Stream stream) { var topic = stream.ReadString(); var isImage = stream.ReadBoolean(); var nbytes = stream.ReadInt32(); var data = new byte[nbytes]; var offset = 0; while (nbytes > 0) { var bytesRead = stream.Read(data, offset, nbytes); if (bytesRead == 0) throw new EndOfStreamException(); nbytes -= bytesRead; offset += bytesRead; } return new MulticastData(topic, isImage, data); }
public static string GetFileExtension(Stream data) { // Check to see if the file is an archive Archive archive = new Archive(data, null); if (archive.Format != ArchiveFormat.NULL) return archive.FileExtension; // Check to see if the file is an image Images images = new Images(data, null); if (images.Format != GraphicFormat.NULL) return images.FileExtension; // Check to see if the file is an ADX (special case) if (data.Length > 4 && data.ReadUShort(0x00) == 0x0080 && data.Length > data.ReadUShort(0x02).SwapEndian() + 4 && data.ReadString(data.ReadUShort(0x02).SwapEndian() - 0x02, 6, true) == "(c)CRI") return ".adx"; // Unknown return String.Empty; }
public static SetupMessage FromStream(DateTime timestamp, Stream stream) { bool? ex = stream.ReadNullBoolean(); bool? low = stream.ReadNullBoolean(); int count = stream.ReadInt32(); var contributors = new Models.GameSettings.Contributor[count]; for (int i = 0; i < count; i++) { var name = stream.ReadString(); var active = stream.ReadBoolean(); contributors[i] = new Models.GameSettings.Contributor() { Name = name, Active = active }; } var settings = new Models.GameSettings() { ExcludeMerges = ex, LowerCase = low, Contributors = contributors }; return new SetupMessage(timestamp, settings); }