/** * The equals method doesn't always work--mostly on on classes that consist only of primitives. Be careful. */ public bool equals(VariableDatum rhs) { bool ivarsEqual = true; if (rhs.GetType() != this.GetType()) { return(false); } if (!(_variableDatumID == rhs._variableDatumID)) { ivarsEqual = false; } if (!(_variableDatumLength == rhs._variableDatumLength)) { ivarsEqual = false; } for (int idx = 0; idx < _variableDatums.Count; idx++) { EightByteChunk x = (EightByteChunk)_variableDatums[idx]; if (!(_variableDatums[idx].Equals(rhs._variableDatums[idx]))) { ivarsEqual = false; } } return(ivarsEqual); }
/** * Compares for reference equality and value equality. */ public bool equals(EightByteChunk rhs) { bool ivarsEqual = true; if (rhs.GetType() != this.GetType()) { return(false); } if (!(rhs._otherParameters.Length == 8)) { ivarsEqual = false; } if (ivarsEqual) { for (int idx = 0; idx < 8; idx++) { if (!(_otherParameters[idx] == rhs._otherParameters[idx])) { ivarsEqual = false; } } } return(ivarsEqual); }
} // end of unmarshal method ///<summary> ///This allows for a quick display of PDU data. The current format is unacceptable and only used for debugging. ///This will be modified in the future to provide a better display. Usage: ///pdu.GetType().InvokeMember("reflection", System.Reflection.BindingFlags.InvokeMethod, null, pdu, new object[] { sb }); ///where pdu is an object representing a single pdu and sb is a StringBuilder. ///Note: The supplied Utilities folder contains a method called 'DecodePDU' in the PDUProcessor Class that provides this functionality ///</summary> new public void reflection(StringBuilder sb) { sb.Append("<MinefieldResponseNackPdu>" + System.Environment.NewLine); base.reflection(sb); try { sb.Append("<minefieldID>" + System.Environment.NewLine); _minefieldID.reflection(sb); sb.Append("</minefieldID>" + System.Environment.NewLine); sb.Append("<requestingEntityID>" + System.Environment.NewLine); _requestingEntityID.reflection(sb); sb.Append("</requestingEntityID>" + System.Environment.NewLine); sb.Append("<requestID type=\"byte\">" + _requestID.ToString() + "</requestID> " + System.Environment.NewLine); sb.Append("<missingPduSequenceNumbers type=\"byte\">" + _missingPduSequenceNumbers.Count.ToString() + "</missingPduSequenceNumbers> " + System.Environment.NewLine); for (int idx = 0; idx < _missingPduSequenceNumbers.Count; idx++) { sb.Append("<missingPduSequenceNumbers" + idx.ToString() + " type=\"EightByteChunk\">" + System.Environment.NewLine); EightByteChunk aEightByteChunk = (EightByteChunk)_missingPduSequenceNumbers[idx]; aEightByteChunk.reflection(sb); sb.Append("</missingPduSequenceNumbers" + idx.ToString() + ">" + System.Environment.NewLine); } // end of list marshalling sb.Append("</MinefieldResponseNackPdu>" + System.Environment.NewLine); } // end try catch (Exception e) { Trace.WriteLine(e); Trace.Flush(); } } // end of marshal method
/// <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 List <DIS1998net.EightByteChunk> ArrayToEightByteChunks(Array data) { //If no data exists return null if (data.Length == 0) { return(null); } //Used to get the length of the data DIS1998net.EightByteChunk byteChunkData = new DIS1998net.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 <DIS1998net.EightByteChunk> byteChunkList = new List <DIS1998net.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 DIS1998net.EightByteChunk(); Buffer.BlockCopy(chunkBuffer, i * lengthByteChunkData, byteChunkData.OtherParameters, 0, lengthByteChunkData); byteChunkList.Add(byteChunkData); } return(byteChunkList); }
public int getMarshalledSize() { int marshalSize = 0; marshalSize = marshalSize + 4; // _variableDatumID marshalSize = marshalSize + 4; // _variableDatumLength for (int idx = 0; idx < _variableDatums.Count; idx++) { EightByteChunk listElement = (EightByteChunk)_variableDatums[idx]; marshalSize = marshalSize + listElement.getMarshalledSize(); } return(marshalSize); }
new public int getMarshalledSize() { int marshalSize = 0; marshalSize = base.getMarshalledSize(); marshalSize = marshalSize + _minefieldID.getMarshalledSize(); // _minefieldID marshalSize = marshalSize + _requestingEntityID.getMarshalledSize(); // _requestingEntityID marshalSize = marshalSize + 1; // _requestID marshalSize = marshalSize + 1; // _numberOfMissingPdus for (int idx = 0; idx < _missingPduSequenceNumbers.Count; idx++) { EightByteChunk listElement = (EightByteChunk)_missingPduSequenceNumbers[idx]; marshalSize = marshalSize + listElement.getMarshalledSize(); } return(marshalSize); }
///<summary> ///Marshal the data to the DataOutputStream. Note: Length needs to be set before calling this method ///</summary> public void marshal(DataOutputStream dos) { try { dos.writeUint((uint)_variableDatumID); dos.writeUint((uint)_variableDatumLength); //Post processed for (int idx = 0; idx < _variableDatums.Count; idx++) { EightByteChunk aEightByteChunk = (EightByteChunk)_variableDatums[idx]; aEightByteChunk.marshal(dos); } // end of list marshalling } // end try catch (Exception e) { Trace.WriteLine(e); Trace.Flush(); } } // end of marshal method
/// <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 List <DIS1998net.EightByteChunk> ArrayToEightByteChunks(Array data) { //If no data exists return null if (data.Length == 0) { return(null); } int result = 0; //Used to get the length of the data DIS1998net.EightByteChunk byteChunkData = new DIS1998net.EightByteChunk(); int lengthByteChunkData = byteChunkData.OtherParameters.Length; //Calculate the size if not on the byte boundary then all 1 to make it so int maxSize = Math.DivRem(data.Length, lengthByteChunkData, out result); if (result != 0) { maxSize++; } //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 <DIS1998net.EightByteChunk> byteChunkList = new List <DIS1998net.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 DIS1998net.EightByteChunk(); Buffer.BlockCopy(chunkBuffer, i * lengthByteChunkData, byteChunkData.OtherParameters, 0, lengthByteChunkData); byteChunkList.Add(byteChunkData); } return(byteChunkList); }
} // end of marshal method public void unmarshal(DataInputStream dis) { try { _variableDatumID = dis.readUint(); _variableDatumLength = dis.readUint(); int variableCount = (int)(_variableDatumLength / 64) + (_variableDatumLength % 64 > 0 ? 1 : 0); //Post processed for (int idx = 0; idx < variableCount; idx++) { EightByteChunk anX = new EightByteChunk(); anX.unmarshal(dis); _variableDatums.Add(anX); } ; } // end try catch (Exception e) { Trace.WriteLine(e); Trace.Flush(); } } // end of unmarshal method
///<summary> ///Marshal the data to the DataOutputStream. Note: Length needs to be set before calling this method ///</summary> new public void marshal(DataOutputStream dos) { base.marshal(dos); try { _minefieldID.marshal(dos); _requestingEntityID.marshal(dos); dos.writeByte((byte)_requestID); dos.writeByte((byte)_missingPduSequenceNumbers.Count); for (int idx = 0; idx < _missingPduSequenceNumbers.Count; idx++) { EightByteChunk aEightByteChunk = (EightByteChunk)_missingPduSequenceNumbers[idx]; aEightByteChunk.marshal(dos); } // end of list marshalling } // end try catch (Exception e) { Trace.WriteLine(e); Trace.Flush(); } } // end of marshal method
/// <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 Array EightByteChunksToArray(List <DIS1998net.EightByteChunk> chunkList) { DIS1998net.EightByteChunk byteChunkData = new DIS1998net.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); }
/** * The equals method doesn't always work--mostly on on classes that consist only of primitives. Be careful. */ public bool equals(MinefieldResponseNackPdu rhs) { bool ivarsEqual = true; if (rhs.GetType() != this.GetType()) { return(false); } if (!(_minefieldID.Equals(rhs._minefieldID))) { ivarsEqual = false; } if (!(_requestingEntityID.Equals(rhs._requestingEntityID))) { ivarsEqual = false; } if (!(_requestID == rhs._requestID)) { ivarsEqual = false; } if (!(_numberOfMissingPdus == rhs._numberOfMissingPdus)) { ivarsEqual = false; } for (int idx = 0; idx < _missingPduSequenceNumbers.Count; idx++) { EightByteChunk x = (EightByteChunk)_missingPduSequenceNumbers[idx]; if (!(_missingPduSequenceNumbers[idx].Equals(rhs._missingPduSequenceNumbers[idx]))) { ivarsEqual = false; } } return(ivarsEqual); }
} // end of marshal method new public void unmarshal(DataInputStream dis) { base.unmarshal(dis); try { _minefieldID.unmarshal(dis); _requestingEntityID.unmarshal(dis); _requestID = dis.readByte(); _numberOfMissingPdus = dis.readByte(); for (int idx = 0; idx < _numberOfMissingPdus; idx++) { EightByteChunk anX = new EightByteChunk(); anX.unmarshal(dis); _missingPduSequenceNumbers.Add(anX); } ; } // end try catch (Exception e) { Trace.WriteLine(e); Trace.Flush(); } } // end of unmarshal method
} // end of unmarshal method ///<summary> ///This allows for a quick display of PDU data. The current format is unacceptable and only used for debugging. ///This will be modified in the future to provide a better display. Usage: ///pdu.GetType().InvokeMember("reflection", System.Reflection.BindingFlags.InvokeMethod, null, pdu, new object[] { sb }); ///where pdu is an object representing a single pdu and sb is a StringBuilder. ///Note: The supplied Utilities folder contains a method called 'DecodePDU' in the PDUProcessor Class that provides this functionality ///</summary> public void reflection(StringBuilder sb) { sb.Append("<VariableDatum>" + System.Environment.NewLine); try { sb.Append("<variableDatumID type=\"uint\">" + _variableDatumID.ToString() + "</variableDatumID> " + System.Environment.NewLine); sb.Append("<variableDatums type=\"uint\">" + _variableDatums.Count.ToString() + "</variableDatums> " + System.Environment.NewLine); for (int idx = 0; idx < _variableDatums.Count; idx++) { sb.Append("<variableDatums" + idx.ToString() + " type=\"EightByteChunk\">" + System.Environment.NewLine); EightByteChunk aEightByteChunk = (EightByteChunk)_variableDatums[idx]; aEightByteChunk.reflection(sb); sb.Append("</variableDatums" + idx.ToString() + ">" + System.Environment.NewLine); } // end of list marshalling sb.Append("</VariableDatum>" + System.Environment.NewLine); } // end try catch (Exception e) { Trace.WriteLine(e); Trace.Flush(); } } // end of marshal method
/// <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 List<DIS1998net.EightByteChunk> ArrayToEightByteChunks(Array data) { //If no data exists return null if (data.Length == 0) return null; //Used to get the length of the data DIS1998net.EightByteChunk byteChunkData = new DIS1998net.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<DIS1998net.EightByteChunk> byteChunkList = new List<DIS1998net.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 DIS1998net.EightByteChunk(); Buffer.BlockCopy(chunkBuffer, i * lengthByteChunkData, byteChunkData.OtherParameters, 0, lengthByteChunkData); byteChunkList.Add(byteChunkData); } return byteChunkList; }
public void unmarshal(DataInputStream dis) { try { _variableDatumID = dis.readUint(); _variableDatumLength = dis.readUint(); int variableCount = (int)(_variableDatumLength / 64) + (_variableDatumLength % 64 > 0 ? 1 : 0); //Post processed for(int idx = 0; idx < variableCount; idx++) { EightByteChunk anX = new EightByteChunk(); anX.unmarshal(dis); _variableDatums.Add(anX); }; } // end try catch(Exception e) { Trace.WriteLine(e); Trace.Flush(); } }
/// <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 Array EightByteChunksToArray(List<DIS1998net.EightByteChunk> chunkList) { DIS1998net.EightByteChunk byteChunkData = new DIS1998net.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> /// 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 List<DIS1998net.EightByteChunk> ArrayToEightByteChunks(Array data) { //If no data exists return null if (data.Length == 0) return null; int result = 0; //Used to get the length of the data DIS1998net.EightByteChunk byteChunkData = new DIS1998net.EightByteChunk(); int lengthByteChunkData = byteChunkData.OtherParameters.Length; //Calculate the size if not on the byte boundary then all 1 to make it so int maxSize = Math.DivRem(data.Length, lengthByteChunkData, out result); if (result != 0) maxSize++; //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<DIS1998net.EightByteChunk> byteChunkList = new List<DIS1998net.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 DIS1998net.EightByteChunk(); Buffer.BlockCopy(chunkBuffer, i * lengthByteChunkData, byteChunkData.OtherParameters, 0, lengthByteChunkData); byteChunkList.Add(byteChunkData); } return byteChunkList; }
public new void unmarshal(DataInputStream dis) { base.unmarshal(dis); try { _minefieldID.unmarshal(dis); _requestingEntityID.unmarshal(dis); _requestID = dis.readByte(); _numberOfMissingPdus = dis.readByte(); for(int idx = 0; idx < _numberOfMissingPdus; idx++) { EightByteChunk anX = new EightByteChunk(); anX.unmarshal(dis); _missingPduSequenceNumbers.Add(anX); }; } // end try catch(Exception e) { Trace.WriteLine(e); Trace.Flush(); } }
/** * The equals method doesn't always work--mostly on on classes that consist only of primitives. Be careful. */ public bool equals(EightByteChunk rhs) { bool ivarsEqual = true; if(rhs.GetType() != this.GetType()) return false; for(int idx = 0; idx < 8; idx++) { if(!(_otherParameters[idx] == rhs._otherParameters[idx])) ivarsEqual = false; } return ivarsEqual; }