public override void Marshal(DataOutputStream dos) { base.Marshal(dos); if (dos != null) { try { this._minefieldID.Marshal(dos); this._requestingEntityID.Marshal(dos); dos.WriteUnsignedByte((byte)this._requestID); dos.WriteUnsignedByte((byte)this._missingPduSequenceNumbers.Count); for (int idx = 0; idx < this._missingPduSequenceNumbers.Count; idx++) { EightByteChunk aEightByteChunk = (EightByteChunk)this._missingPduSequenceNumbers[idx]; aEightByteChunk.Marshal(dos); } } catch (Exception e) { if (PduBase.TraceExceptions) { Trace.WriteLine(e); Trace.Flush(); } this.RaiseExceptionOccured(e); if (PduBase.ThrowExceptions) { throw e; } } } }
/// <summary> /// Compares for reference AND value equality. /// </summary> /// <param name="obj">The object to compare with this instance.</param> /// <returns> /// <c>true</c> if both operands are equal; otherwise, <c>false</c>. /// </returns> public bool Equals(EightByteChunk obj) { bool ivarsEqual = true; if (obj.GetType() != this.GetType()) { return(false); } if (obj._otherParameters.Length != 8) { ivarsEqual = false; } if (ivarsEqual) { for (int idx = 0; idx < 8; idx++) { if (this._otherParameters[idx] != obj._otherParameters[idx]) { ivarsEqual = false; } } } return(ivarsEqual); }
public virtual void Unmarshal(DataInputStream dis) { if (dis != null) { try { this._variableDatumID = dis.ReadUnsignedInt(); this._variableDatumLength = dis.ReadUnsignedInt(); int variableCount = (int)(this._variableDatumLength / 64) + (this._variableDatumLength % 64 > 0 ? 1 : 0); //Post processed for (int idx = 0; idx < variableCount; idx++) { EightByteChunk anX = new EightByteChunk(); anX.Unmarshal(dis); this._variableDatums.Add(anX); } } catch (Exception e) { if (PduBase.TraceExceptions) { Trace.WriteLine(e); Trace.Flush(); } this.RaiseExceptionOccured(e); if (PduBase.ThrowExceptions) { throw e; } } } }
public virtual void Reflection(StringBuilder sb) { sb.AppendLine("<VariableDatum>"); try { sb.AppendLine("<variableDatumID type=\"uint\">" + this._variableDatumID.ToString(CultureInfo.InvariantCulture) + "</variableDatumID>"); sb.AppendLine("<variableDatums type=\"uint\">" + this._variableDatums.Count.ToString(CultureInfo.InvariantCulture) + "</variableDatums>"); for (int idx = 0; idx < this._variableDatums.Count; idx++) { sb.AppendLine("<variableDatums" + idx.ToString(CultureInfo.InvariantCulture) + " type=\"EightByteChunk\">"); EightByteChunk aEightByteChunk = (EightByteChunk)this._variableDatums[idx]; aEightByteChunk.Reflection(sb); sb.AppendLine("</variableDatums" + idx.ToString(CultureInfo.InvariantCulture) + ">"); } sb.AppendLine("</VariableDatum>"); } catch (Exception e) { if (PduBase.TraceExceptions) { Trace.WriteLine(e); Trace.Flush(); } this.RaiseExceptionOccured(e); if (PduBase.ThrowExceptions) { throw e; } } }
public virtual void Marshal(DataOutputStream dos) { if (dos != null) { try { dos.WriteUnsignedInt((uint)this._variableDatumID); dos.WriteUnsignedInt((uint)this._variableDatumLength); //Post processedtums.Count); for (int idx = 0; idx < this._variableDatums.Count; idx++) { EightByteChunk aEightByteChunk = (EightByteChunk)this._variableDatums[idx]; aEightByteChunk.Marshal(dos); } } catch (Exception e) { if (PduBase.TraceExceptions) { Trace.WriteLine(e); Trace.Flush(); } this.RaiseExceptionOccured(e); if (PduBase.ThrowExceptions) { throw e; } } } }
public virtual int GetMarshalledSize() { int marshalSize = 0; marshalSize += 4; // this._variableDatumID marshalSize += 4; // this._variableDatumLength for (int idx = 0; idx < this._variableDatums.Count; idx++) { EightByteChunk listElement = (EightByteChunk)this._variableDatums[idx]; marshalSize += listElement.GetMarshalledSize(); } return(marshalSize); }
public override int GetMarshalledSize() { int marshalSize = 0; marshalSize = base.GetMarshalledSize(); marshalSize += this._minefieldID.GetMarshalledSize(); // this._minefieldID marshalSize += this._requestingEntityID.GetMarshalledSize(); // this._requestingEntityID marshalSize += 1; // this._requestID marshalSize += 1; // this._numberOfMissingPdus for (int idx = 0; idx < this._missingPduSequenceNumbers.Count; idx++) { EightByteChunk listElement = (EightByteChunk)this._missingPduSequenceNumbers[idx]; marshalSize += listElement.GetMarshalledSize(); } return(marshalSize); }
public override void Reflection(StringBuilder sb) { sb.AppendLine("<MinefieldResponseNackPdu>"); base.Reflection(sb); try { sb.AppendLine("<minefieldID>"); this._minefieldID.Reflection(sb); sb.AppendLine("</minefieldID>"); sb.AppendLine("<requestingEntityID>"); this._requestingEntityID.Reflection(sb); sb.AppendLine("</requestingEntityID>"); sb.AppendLine("<requestID type=\"byte\">" + this._requestID.ToString(CultureInfo.InvariantCulture) + "</requestID>"); sb.AppendLine("<missingPduSequenceNumbers type=\"byte\">" + this._missingPduSequenceNumbers.Count.ToString(CultureInfo.InvariantCulture) + "</missingPduSequenceNumbers>"); for (int idx = 0; idx < this._missingPduSequenceNumbers.Count; idx++) { sb.AppendLine("<missingPduSequenceNumbers" + idx.ToString(CultureInfo.InvariantCulture) + " type=\"EightByteChunk\">"); EightByteChunk aEightByteChunk = (EightByteChunk)this._missingPduSequenceNumbers[idx]; aEightByteChunk.Reflection(sb); sb.AppendLine("</missingPduSequenceNumbers" + idx.ToString(CultureInfo.InvariantCulture) + ">"); } sb.AppendLine("</MinefieldResponseNackPdu>"); } 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._minefieldID.Unmarshal(dis); this._requestingEntityID.Unmarshal(dis); this._requestID = dis.ReadUnsignedByte(); this._numberOfMissingPdus = dis.ReadUnsignedByte(); for (int idx = 0; idx < this.NumberOfMissingPdus; idx++) { EightByteChunk anX = new EightByteChunk(); anX.Unmarshal(dis); this._missingPduSequenceNumbers.Add(anX); } } catch (Exception e) { if (PduBase.TraceExceptions) { Trace.WriteLine(e); Trace.Flush(); } this.RaiseExceptionOccured(e); if (PduBase.ThrowExceptions) { throw e; } } } }
/// <summary> /// Method to convert a byte Array into Eigh tByte Chunks /// </summary> /// <param name="data">Byte array that contains data to convert</param> /// <returns>List containing EightByteChunks</returns> public static List<EightByteChunk> ArrayToEightByteChunks(Array data) { //If no data exists return null if (data.Length == 0) { return null; } // Used to get the length of the data EightByteChunk byteChunkData = new EightByteChunk(); int lengthByteChunkData = byteChunkData.OtherParameters.Length; // Calculate the size if not on the byte boundary then all 1 to make it so int maxSize = System.Convert.ToInt32(Math.Ceiling((double)data.Length / (double)lengthByteChunkData)); //PES09182009 Modified so it would also work on Mobile // Create buffer to hold the data passed in from the array byte[] chunkBuffer = new byte[maxSize * lengthByteChunkData]; // Copy data to the buffer created above Buffer.BlockCopy(data, 0, chunkBuffer, 0, data.Length); List<EightByteChunk> byteChunkList = new List<EightByteChunk>(); // Iterate over the buffer and grab the appropriate number of bytes, store into the List for (int i = 0; i < maxSize; i++) { byteChunkData = new EightByteChunk(); Buffer.BlockCopy(chunkBuffer, i * lengthByteChunkData, byteChunkData.OtherParameters, 0, lengthByteChunkData); byteChunkList.Add(byteChunkData); } return byteChunkList; }
/// <summary> /// Method to convert Eight Byte Chunks into an Array /// </summary> /// <param name="chunkList">List that holds the EightByteChunks</param> /// <returns>Byte array</returns> public static Array EightByteChunksToArray(List<EightByteChunk> chunkList) { EightByteChunk byteChunkData = new EightByteChunk(); int lengthByteChunkData = byteChunkData.OtherParameters.Length; //Data passed in does not exist. if (chunkList.Count == 0) { return null; } // Create the appropriate sized buffer for this type byte[] chunkBuffer = new byte[chunkList.Count * lengthByteChunkData]; // Go through each item and append to the buffer for (int i = 0; i < chunkList.Count; i++) { Buffer.BlockCopy(chunkList[i].OtherParameters, 0, chunkBuffer, i * lengthByteChunkData, lengthByteChunkData); } return (Array)chunkBuffer; }
/// <summary> /// Compares for reference AND value equality. /// </summary> /// <param name="obj">The object to compare with this instance.</param> /// <returns> /// <c>true</c> if both operands are equal; otherwise, <c>false</c>. /// </returns> public bool Equals(EightByteChunk obj) { bool ivarsEqual = true; if (obj.GetType() != this.GetType()) { return false; } if (obj._otherParameters.Length != 8) { ivarsEqual = false; } if (ivarsEqual) { for (int idx = 0; idx < 8; idx++) { if (this._otherParameters[idx] != obj._otherParameters[idx]) { ivarsEqual = false; } } } return ivarsEqual; }