/* * Loads the sprite data and index files from the cache location. * This can be edited to use an archive such as config or media to load from the cache. * * @param archive */ public static void loadSprites(StreamLoader streamLoader) { //try { RS2Sharp.Stream index = new RS2Sharp.Stream(UnityClient.ReadAllBytes(signlink.findcachedir() + "sprites.idx")); RS2Sharp.Stream data = new RS2Sharp.Stream(UnityClient.ReadAllBytes(signlink.findcachedir() + "sprites.dat")); DataInputStream indexFile = new DataInputStream(new Ionic.Zlib.GZipStream(new MemoryStream(index.buffer), Ionic.Zlib.CompressionMode.Decompress)); DataInputStream dataFile = new DataInputStream(new Ionic.Zlib.GZipStream(new MemoryStream(data.buffer), Ionic.Zlib.CompressionMode.Decompress)); int totalSprites = indexFile.ReadInt(); UnityEngine.Debug.Log("Sprites loaded: " + totalSprites); if (cache == null) { cache = new SpriteLoader[totalSprites]; sprites = new Sprite[totalSprites]; } for (int i = 0; i < totalSprites; i++) { int id = indexFile.ReadInt(); if (cache[id] == null) { cache[id] = new SpriteLoader(); } cache[id].readValues(indexFile, dataFile); createSprite(cache[id]); } //indexFile.Close(); //dataFile.Close(); //} catch (Exception e) { // e.printStackTrace(); //} }
private void HandleInvitation(DataInputStream dataInputStream, model.RtpMidiServer rtpMidiServer) { int protocolVersion = dataInputStream.ReadInt(); if (protocolVersion != PROTOCOL_VERSION) { Log.Info("RtpMidi", "Protocol version: {} did not match version {}", protocolVersion, PROTOCOL_VERSION); return; } int initiatorToken = dataInputStream.ReadInt(); int ssrc = dataInputStream.ReadInt(); //Scanner scanner = new Scanner(dataInputStream).UseDelimiter(NUL_TERMINATOR); //if (!scanner.HasNext) //{ // Log.Info("RtpMidi","Could not find \\0 terminating string"); // return; //} //string name = scanner.Next(); string name = dataInputStream.ReadLine(); foreach (IRtpMidiCommandListener listener in listeners) { listener.OnMidiInvitation(new RtpMidiInvitationRequest(protocolVersion, initiatorToken, ssrc, name), rtpMidiServer); } }
/// <summary>A TagCount object's fields are read from the file.</summary> /// <remarks> /// A TagCount object's fields are read from the file. They are read from /// the current position and the file is not closed afterwards. /// </remarks> public static Edu.Stanford.Nlp.Tagger.Maxent.TagCount ReadTagCount(DataInputStream rf) { try { Edu.Stanford.Nlp.Tagger.Maxent.TagCount tc = new Edu.Stanford.Nlp.Tagger.Maxent.TagCount(); int numTags = rf.ReadInt(); tc.map = Generics.NewHashMap(numTags); for (int i = 0; i < numTags; i++) { string tag = rf.ReadUTF(); int count = rf.ReadInt(); if (tag.Equals(NullSymbol)) { tag = null; } tc.map[tag] = count; } tc.getTagsCache = Sharpen.Collections.ToArray(tc.map.Keys, new string[tc.map.Keys.Count]); tc.sumCache = tc.CalculateSumCache(); return(tc); } catch (IOException e) { throw new RuntimeIOException(e); } }
/// <summary>Read word vectors from an input stream.</summary> /// <remarks>Read word vectors from an input stream. The stream is not closed on finishing the function.</remarks> /// <param name="in">The stream to read from. This is not closed.</param> /// <returns>The word vectors encoded on the stream.</returns> /// <exception cref="System.IO.IOException">Thrown if we could not read from the stream.</exception> public static VectorMap Deserialize(InputStream @in) { DataInputStream dataIn = new DataInputStream(@in); // Read the max key length VectorMap.Itype keyIntType = VectorMap.Itype.GetType(dataIn.ReadInt()); // Read the vector dimensionality int dim = dataIn.ReadInt(); // Read the size of the dataset int size = dataIn.ReadInt(); // Read the vectors VectorMap vectors = new VectorMap(); for (int i = 0; i < size; ++i) { // Read the key int strlen = keyIntType.Read(dataIn); byte[] buffer = new byte[strlen]; if (dataIn.Read(buffer, 0, strlen) != strlen) { throw new IOException("Could not read string buffer fully!"); } string key = Sharpen.Runtime.GetStringForBytes(buffer); // Read the vector float[] vector = new float[dim]; for (int k = 0; k < vector.Length; ++k) { vector[k] = ToFloat(dataIn.ReadShort()); } // Add the key/value vectors[key] = vector; } return(vectors); }
// protected constructor ------------------------------------------- /// <summary> /// Trie constructor for CharTrie use. /// </summary> /// /// <param name="inputStream">ICU data file input stream which contains the trie</param> /// <param name="dataManipulate">object containing the information to parse the trie data</param> /// <exception cref="IOException">thrown when input stream does not have the right header.</exception> /// @draft 2.1 protected internal Trie(DataInputStream inputStream, Trie.DataManipulate dataManipulate) { DataInputStream input = inputStream; // new DataInputStream(inputStream); // Magic number to authenticate the data. int signature = input.ReadInt(); m_options_ = input.ReadInt(); if (!CheckHeader(signature)) { throw new ArgumentException( "ICU data file error: Trie header authentication failed, please check if you have the most updated ICU data file"); } if (dataManipulate != null) { m_dataManipulate_ = dataManipulate; } else { m_dataManipulate_ = new Trie.DefaultGetFoldingOffset(); } m_isLatin1Linear_ = (m_options_ & HEADER_OPTIONS_LATIN1_IS_LINEAR_MASK_) != 0; m_dataOffset_ = input.ReadInt(); m_dataLength_ = input.ReadInt(); Unserialize(inputStream); }
private void ReadData(Stream stream) { DataInputStream ds = new DataInputStream(stream); /* if (DEBUG) * System.Console.Out.WriteLine("The DataInputStream class is: " + ds.GetType().FullName); + if (DEBUG) + System.Console.Out + .WriteLine("The available bytes in the stream before reading the data: " + ds.Available()); */ /* * The following will read two integers before ds.mark(). Later, the two * integers need to be placed into data[], then ds.reset(), then * ds.readFully(into rest of data[]). * * This is necessary because we don't know the readLimit for ds.mark() * until we have read the second integer (indexLength). */ rootRes = ds.ReadInt(); // read the variable-length indexes[] array int indexLength = ds.ReadInt(); ds.Mark((indexLength - 1) * 4); indexes = new int[indexLength]; indexes[URES_INDEX_LENGTH] = indexLength; for (int i = 1; i < indexLength; i++) { indexes[i] = ds.ReadInt(); } // determine if this resource bundle falls back to a parent bundle // along normal locale ID fallback noFallback = indexLength > URES_INDEX_ATTRIBUTES && (indexes[URES_INDEX_ATTRIBUTES] & URES_ATT_NO_FALLBACK) != 0; // read the entire bundle (after the header) into data[] // put rootRes and indexLength into data[0..7] // and the rest of the data into data[8..length-1] int length = indexes[URES_INDEX_BUNDLE_TOP] * 4; if (DEBUG) { System.Console.Out.WriteLine("The number of bytes in the bundle: " + length); } data = new sbyte[length]; WriteInt(rootRes, data, 0); WriteInt(indexLength, data, 4); // now reset to the mark, which was set after reading rootRes and // indexLength ds.Reset(); ds.ReadFully(data, 8, length - 8); }
public override void FromInputStream(DataInputStream reader) { int actionID = reader.ReadInt(); try { PerformedAction = (ButtonAction)actionID; SlotID = reader.ReadInt(); } catch (Exception) { //Ignore malformed packet } }
/// <exception cref="System.IO.IOException"/> private void ProcessDirectoryDiff(DataInputStream @in, ImageVisitor v, string currentINodeName ) { v.VisitEnclosingElement(ImageVisitor.ImageElement.SnapshotDirDiff); int snapshotId = @in.ReadInt(); v.Visit(ImageVisitor.ImageElement.SnapshotDiffSnapshotid, snapshotId); v.Visit(ImageVisitor.ImageElement.SnapshotDirDiffChildrenSize, @in.ReadInt()); // process snapshotINode bool useRoot = @in.ReadBoolean(); if (!useRoot) { if (@in.ReadBoolean()) { v.VisitEnclosingElement(ImageVisitor.ImageElement.SnapshotInodeDirectoryAttributes ); if (NameNodeLayoutVersion.Supports(LayoutVersion.Feature.OptimizeSnapshotInodes, imageVersion)) { ProcessINodeDirectoryAttributes(@in, v, currentINodeName); } else { ProcessINode(@in, v, true, currentINodeName, true); } v.LeaveEnclosingElement(); } } // process createdList int createdSize = @in.ReadInt(); v.VisitEnclosingElement(ImageVisitor.ImageElement.SnapshotDirDiffCreatedlist, ImageVisitor.ImageElement .SnapshotDirDiffCreatedlistSize, createdSize); for (int i = 0; i < createdSize; i++) { string createdNode = FSImageSerialization.ReadString(@in); v.Visit(ImageVisitor.ImageElement.SnapshotDirDiffCreatedInode, createdNode); } v.LeaveEnclosingElement(); // process deletedList int deletedSize = @in.ReadInt(); v.VisitEnclosingElement(ImageVisitor.ImageElement.SnapshotDirDiffDeletedlist, ImageVisitor.ImageElement .SnapshotDirDiffDeletedlistSize, deletedSize); for (int i_1 = 0; i_1 < deletedSize; i_1++) { v.VisitEnclosingElement(ImageVisitor.ImageElement.SnapshotDirDiffDeletedInode); ProcessINode(@in, v, false, currentINodeName, true); v.LeaveEnclosingElement(); } v.LeaveEnclosingElement(); v.LeaveEnclosingElement(); }
public override void Unmarshal(DataInputStream dis) { base.Unmarshal(dis); if (dis != null) { try { this._entityID.Unmarshal(dis); this._forceId = dis.ReadUnsignedByte(); this._articulationParameterCount = dis.ReadByte(); this._entityType.Unmarshal(dis); this._alternativeEntityType.Unmarshal(dis); this._entityLinearVelocity.Unmarshal(dis); this._entityLocation.Unmarshal(dis); this._entityOrientation.Unmarshal(dis); this._entityAppearance = dis.ReadInt(); this._deadReckoningParameters.Unmarshal(dis); for (int idx = 0; idx < this._marking.Length; idx++) { this._marking[idx] = dis.ReadByte(); } this._capabilities = dis.ReadInt(); for (int idx = 0; idx < this.ArticulationParameterCount; idx++) { ArticulationParameter anX = new ArticulationParameter(); anX.Unmarshal(dis); this._articulationParameters.Add(anX); } } catch (Exception e) { if (PduBase.TraceExceptions) { Trace.WriteLine(e); Trace.Flush(); } this.RaiseExceptionOccured(e); if (PduBase.ThrowExceptions) { throw e; } } } }
// DELEGATION_TOKENS /// <summary>Process the INodes under construction section of the fsimage.</summary> /// <param name="in">DataInputStream to process</param> /// <param name="v">Visitor to walk over inodes</param> /// <param name="skipBlocks">Walk over each block?</param> /// <exception cref="System.IO.IOException"/> private void ProcessINodesUC(DataInputStream @in, ImageVisitor v, bool skipBlocks ) { int numINUC = @in.ReadInt(); v.VisitEnclosingElement(ImageVisitor.ImageElement.InodesUnderConstruction, ImageVisitor.ImageElement .NumInodesUnderConstruction, numINUC); for (int i = 0; i < numINUC; i++) { v.VisitEnclosingElement(ImageVisitor.ImageElement.InodeUnderConstruction); byte[] name = FSImageSerialization.ReadBytes(@in); string n = Sharpen.Runtime.GetStringForBytes(name, "UTF8"); v.Visit(ImageVisitor.ImageElement.InodePath, n); if (NameNodeLayoutVersion.Supports(LayoutVersion.Feature.AddInodeId, imageVersion )) { long inodeId = @in.ReadLong(); v.Visit(ImageVisitor.ImageElement.InodeId, inodeId); } v.Visit(ImageVisitor.ImageElement.Replication, @in.ReadShort()); v.Visit(ImageVisitor.ImageElement.ModificationTime, FormatDate(@in.ReadLong())); v.Visit(ImageVisitor.ImageElement.PreferredBlockSize, @in.ReadLong()); int numBlocks = @in.ReadInt(); ProcessBlocks(@in, v, numBlocks, skipBlocks); ProcessPermission(@in, v); v.Visit(ImageVisitor.ImageElement.ClientName, FSImageSerialization.ReadString(@in )); v.Visit(ImageVisitor.ImageElement.ClientMachine, FSImageSerialization.ReadString( @in)); // Skip over the datanode descriptors, which are still stored in the // file but are not used by the datanode or loaded into memory int numLocs = @in.ReadInt(); for (int j = 0; j < numLocs; j++) { @in.ReadShort(); @in.ReadLong(); @in.ReadLong(); @in.ReadLong(); @in.ReadInt(); FSImageSerialization.ReadString(@in); FSImageSerialization.ReadString(@in); WritableUtils.ReadEnum <DatanodeInfo.AdminStates>(@in); } v.LeaveEnclosingElement(); } // INodeUnderConstruction v.LeaveEnclosingElement(); }
/// <summary>Process the Delegation Token related section in fsimage.</summary> /// <param name="in">DataInputStream to process</param> /// <param name="v">Visitor to walk over records</param> /// <exception cref="System.IO.IOException"/> private void ProcessDelegationTokens(DataInputStream @in, ImageVisitor v) { v.Visit(ImageVisitor.ImageElement.CurrentDelegationKeyId, @in.ReadInt()); int numDKeys = @in.ReadInt(); v.VisitEnclosingElement(ImageVisitor.ImageElement.DelegationKeys, ImageVisitor.ImageElement .NumDelegationKeys, numDKeys); for (int i = 0; i < numDKeys; i++) { DelegationKey key = new DelegationKey(); key.ReadFields(@in); v.Visit(ImageVisitor.ImageElement.DelegationKey, key.ToString()); } v.LeaveEnclosingElement(); v.Visit(ImageVisitor.ImageElement.DelegationTokenSequenceNumber, @in.ReadInt()); int numDTokens = @in.ReadInt(); v.VisitEnclosingElement(ImageVisitor.ImageElement.DelegationTokens, ImageVisitor.ImageElement .NumDelegationTokens, numDTokens); for (int i_1 = 0; i_1 < numDTokens; i_1++) { DelegationTokenIdentifier id = new DelegationTokenIdentifier(); id.ReadFields(@in); long expiryTime = @in.ReadLong(); v.VisitEnclosingElement(ImageVisitor.ImageElement.DelegationTokenIdentifier); v.Visit(ImageVisitor.ImageElement.DelegationTokenIdentifierKind, id.GetKind().ToString ()); v.Visit(ImageVisitor.ImageElement.DelegationTokenIdentifierSeqno, id.GetSequenceNumber ()); v.Visit(ImageVisitor.ImageElement.DelegationTokenIdentifierOwner, id.GetOwner().ToString ()); v.Visit(ImageVisitor.ImageElement.DelegationTokenIdentifierRenewer, id.GetRenewer ().ToString()); v.Visit(ImageVisitor.ImageElement.DelegationTokenIdentifierRealuser, id.GetRealUser ().ToString()); v.Visit(ImageVisitor.ImageElement.DelegationTokenIdentifierIssueDate, id.GetIssueDate ()); v.Visit(ImageVisitor.ImageElement.DelegationTokenIdentifierMaxDate, id.GetMaxDate ()); v.Visit(ImageVisitor.ImageElement.DelegationTokenIdentifierExpiryTime, expiryTime ); v.Visit(ImageVisitor.ImageElement.DelegationTokenIdentifierMasterKeyId, id.GetMasterKeyId ()); v.LeaveEnclosingElement(); } // DELEGATION_TOKEN_IDENTIFIER v.LeaveEnclosingElement(); }
// private methods --------------------------------------------------- /// <summary> /// Reads an individual record of AlgorithmNames /// </summary> /// /// <returns>an instance of AlgorithNames if read is successful otherwise null</returns> /// <exception cref="IOException">thrown when file read error occurs or data is corrupted</exception> private UCharacterName.AlgorithmName ReadAlg() { UCharacterName.AlgorithmName result = new UCharacterName.AlgorithmName(); int rangestart = m_dataInputStream_.ReadInt(); int rangeend = m_dataInputStream_.ReadInt(); sbyte type = m_dataInputStream_.ReadByte(); sbyte variant = m_dataInputStream_.ReadByte(); if (!result.SetInfo(rangestart, rangeend, type, variant)) { return(null); } int size = m_dataInputStream_.ReadChar(); if (type == IBM.ICU.Impl.UCharacterName.AlgorithmName.TYPE_1_) { char[] factor = new char[variant]; for (int j = 0; j < variant; j++) { factor[j] = m_dataInputStream_.ReadChar(); } result.SetFactor(factor); size -= (variant << 1); } StringBuilder prefix = new StringBuilder(); char c = (char)(m_dataInputStream_.ReadByte() & 0x00FF); while (c != 0) { prefix.Append(c); c = (char)(m_dataInputStream_.ReadByte() & 0x00FF); } result.SetPrefix(prefix.ToString()); size -= (ALG_INFO_SIZE_ + prefix.Length + 1); if (size > 0) { byte[] str0 = new byte[size]; m_dataInputStream_.ReadFully(str0); result.SetFactorString(str0); } return(result); }
public override void Unmarshal(DataInputStream dis) { base.Unmarshal(dis); if (dis != null) { try { this._originatingSimulationAddress.Unmarshal(dis); this._padding1 = dis.ReadInt(); this._padding2 = dis.ReadShort(); this._attributeRecordPduType = dis.ReadUnsignedByte(); this._attributeRecordProtocolVersion = dis.ReadUnsignedByte(); this._masterAttributeRecordType = dis.ReadUnsignedInt(); this._actionCode = dis.ReadUnsignedByte(); this._padding3 = dis.ReadByte(); this._numberAttributeRecordSet = dis.ReadUnsignedShort(); } catch (Exception e) { #if DEBUG Trace.WriteLine(e); Trace.Flush(); #endif this.OnException(e); } } }
public virtual void Unmarshal(DataInputStream dis) { if (dis != null) { try { this._numberOfPdus = dis.ReadInt(); for (int idx = 0; idx < this.NumberOfPdus; idx++) { Pdu anX = new Pdu(); anX.Unmarshal(dis); this._pdus.Add(anX); } } catch (Exception e) { if (PduBase.TraceExceptions) { Trace.WriteLine(e); Trace.Flush(); } this.RaiseExceptionOccured(e); if (PduBase.ThrowExceptions) { throw e; } } } }
public override void Unmarshal(DataInputStream dis) { base.Unmarshal(dis); if (dis != null) { try { this._entityID.Unmarshal(dis); this._padding1 = dis.ReadByte(); this._numberOfArticulationParameters = dis.ReadUnsignedByte(); this._entityLinearVelocity.Unmarshal(dis); this._entityLocation.Unmarshal(dis); this._entityOrientation.Unmarshal(dis); this._entityAppearance = dis.ReadInt(); for (int idx = 0; idx < this.NumberOfArticulationParameters; idx++) { ArticulationParameter anX = new ArticulationParameter(); anX.Unmarshal(dis); this._articulationParameters.Add(anX); } ; } catch (Exception e) { #if DEBUG Trace.WriteLine(e); Trace.Flush(); #endif this.OnException(e); } } }
/// <exception cref="System.IO.IOException"/> private static int ReadLeadingInt(Text txt) { DataInputStream @in = new DataInputStream(new ByteArrayInputStream(txt.GetBytes() )); return(@in.ReadInt()); }
/// <exception cref="System.IO.IOException"/> private void ProcessTokenAddOrUpdate(ChildData data) { ByteArrayInputStream bin = new ByteArrayInputStream(data.GetData()); DataInputStream din = new DataInputStream(bin); TokenIdent ident = CreateIdentifier(); ident.ReadFields(din); long renewDate = din.ReadLong(); int pwdLen = din.ReadInt(); byte[] password = new byte[pwdLen]; int numRead = din.Read(password, 0, pwdLen); if (numRead > -1) { AbstractDelegationTokenSecretManager.DelegationTokenInformation tokenInfo = new AbstractDelegationTokenSecretManager.DelegationTokenInformation (renewDate, password); lock (this) { currentTokens[ident] = tokenInfo; // The cancel task might be waiting Runtime.NotifyAll(this); } } }
public virtual void Unmarshal(DataInputStream dis) { if (dis != null) { try { this._numberOfPdus = dis.ReadInt(); for (int idx = 0; idx < this.NumberOfPdus; idx++) { Pdu anX = new Pdu(); anX.Unmarshal(dis); this._pdus.Add(anX); } ; } catch (Exception e) { #if DEBUG Trace.WriteLine(e); Trace.Flush(); #endif this.OnException(e); } } }
/// <exception cref="System.IO.IOException"/> private void LoadLatestSequenceNumber(TimelineStateStore.TimelineServiceState state ) { byte[] data = null; try { data = db.Get(LatestSequenceNumberKey); } catch (DBException e) { throw new IOException(e); } if (data != null) { DataInputStream @in = new DataInputStream(new ByteArrayInputStream(data)); try { state.latestSequenceNumber = @in.ReadInt(); } finally { IOUtils.Cleanup(Log, @in); } } }
public override void Unmarshal(DataInputStream dis) { base.Unmarshal(dis); if (dis != null) { try { this._munitionID.Unmarshal(dis); this._eventID.Unmarshal(dis); this._fireMissionIndex = dis.ReadInt(); this._locationInWorldCoordinates.Unmarshal(dis); this._burstDescriptor.Unmarshal(dis); this._velocity.Unmarshal(dis); this._range = dis.ReadFloat(); } catch (Exception e) { #if DEBUG Trace.WriteLine(e); Trace.Flush(); #endif this.OnException(e); } } }
/* * Reads the information from the index and data files. * * @param index holds the sprite indices * @param data holds the sprite data per index * @throws IOException */ public void readValues(DataInputStream index, DataInputStream data) { do { int opCode = data.ReadByte(); if (opCode == 0) { break; } if (opCode == 1) { id = data.ReadShort(); } else if (opCode == 2) { name = data.ReadUTF(); } else if (opCode == 3) { drawOffsetX = data.ReadShort(); } else if (opCode == 4) { drawOffsetY = data.ReadShort(); } else if (opCode == 5) { int indexLength = index.ReadInt(); byte[] dataread = new byte[indexLength]; data.Read(dataread, 0, indexLength); spriteData = dataread; } } while (true); }
public virtual void Unmarshal(DataInputStream dis) { if (dis != null) { try { this._parameterTypeDesignator = dis.ReadUnsignedByte(); this._changeIndicator = dis.ReadUnsignedByte(); this._partAttachedTo = dis.ReadUnsignedShort(); this._parameterType = dis.ReadInt(); this._parameterValue = dis.ReadDouble(); } catch (Exception e) { if (PduBase.TraceExceptions) { Trace.WriteLine(e); Trace.Flush(); } this.RaiseExceptionOccured(e); if (PduBase.ThrowExceptions) { throw e; } } } }
internal static void CheckIsPreview(InputStream classInputStream) { if (classInputStream == null) { throw new InvalidOperationException("Bytecode not available, can't check class version" ); } int minorVersion; try { using (var callerClassStream = new DataInputStream(classInputStream)) { callerClassStream.ReadInt(); minorVersion = callerClassStream.ReadUnsignedShort(); } } catch (IOException ioe) { throw new InvalidOperationException("I/O error, can't check class version", ioe); } if (minorVersion != 0xFFFF) { throw new InvalidOperationException( "ASM8_EXPERIMENTAL can only be used by classes compiled with --enable-preview" ); } }
/// <summary>Read an integer of this type from the given input stream</summary> /// <exception cref="System.IO.IOException"/> public int Read(DataInputStream @in) { switch (this) { case VectorMap.Itype.Int8: { return(@in.ReadByte()); } case VectorMap.Itype.Int16: { return(@in.ReadShort()); } case VectorMap.Itype.Int32: { return(@in.ReadInt()); } default: { throw new Exception("Unknown itype: " + this); } } }
public void read(DataInputStream dai, bool oldVersion) { int v = dai.ReadInt(); if (v == 1) { long l = dai.ReadLong(); refTime = l == -1 ? null : new Time(l); for (int i = 0; i < 3; i++) { ecef.set(i, dai.ReadDouble()); } for (int i = 0; i < 3; i++) { enu.set(i, dai.ReadDouble()); } for (int i = 0; i < 3; i++) { geod.set(i, dai.ReadDouble()); } } else { throw new IOException("Unknown format version:" + v); } }
public virtual void Unmarshal(DataInputStream dis) { if (dis != null) { try { this._hour = dis.ReadInt(); this._timePastHour = dis.ReadUnsignedInt(); } catch (Exception e) { if (PduBase.TraceExceptions) { Trace.WriteLine(e); Trace.Flush(); } this.RaiseExceptionOccured(e); if (PduBase.ThrowExceptions) { throw e; } } } }
public override void Unmarshal(DataInputStream dis) { base.Unmarshal(dis); if (dis != null) { try { this._munitionID.Unmarshal(dis); this._eventID.Unmarshal(dis); this._fireMissionIndex = dis.ReadInt(); this._locationInWorldCoordinates.Unmarshal(dis); this._burstDescriptor.Unmarshal(dis); this._velocity.Unmarshal(dis); this._range = dis.ReadFloat(); } catch (Exception e) { if (PduBase.TraceExceptions) { Trace.WriteLine(e); Trace.Flush(); } this.RaiseExceptionOccured(e); if (PduBase.ThrowExceptions) { throw e; } } } }
/// <exception cref="System.IO.IOException"/> public static double[] ReadDoubleArr(DataInputStream rf) { int size = rf.ReadInt(); byte[] b = new byte[8 * size]; rf.Read(b); return(ByteArrToDoubleArr(b)); }
/// <exception cref="System.IO.IOException"/> public static float[] ReadFloatArr(DataInputStream rf) { int size = rf.ReadInt(); byte[] b = new byte[4 * size]; rf.Read(b); return(ByteArrToFloatArr(b)); }
private void HandleEndSession(DataInputStream dataInputStream, model.RtpMidiServer rtpMidiServer) { int protocolVersion = dataInputStream.ReadInt(); if (protocolVersion != PROTOCOL_VERSION) { Log.Info("RtpMidi", "Protocol version: {} did not match version {}", protocolVersion, PROTOCOL_VERSION); return; } int initiatorToken = dataInputStream.ReadInt(); int ssrc = dataInputStream.ReadInt(); foreach (IRtpMidiCommandListener listener in listeners) { listener.OnEndSession(new RtpMidiEndSession(protocolVersion, initiatorToken, ssrc), rtpMidiServer); } }