private static Header CreateArrayHeader(JProperty header) { var result = new HeaderArray { Items = new[] { ParseItems(header["items"]) } }; return result; }
/// <summary> /// Asynchronously enumerates the arrays from file. /// </summary> /// <param name="file"> /// The file from which to read arrays. /// </param> /// <returns> /// An enumerable collection of tasks that when completed return an <see cref="IHeaderArray"/> from file. /// </returns> public override IEnumerable <Task <IHeaderArray> > ReadArraysAsync(FilePath file) { using (ZipArchive archive = ZipFile.Open(file, ZipArchiveMode.Read)) { foreach (ZipArchiveEntry entry in archive.Entries) { yield return(Task.Run(async() => HeaderArray.Deserialize(await new StreamReader(entry.Open()).ReadToEndAsync()))); } } }
public Connection(TcpClient tcpClient) { Connected = true; VCList = new Queue <VesselControls>(); MCPList = new Queue <ManChangePacket>(); sendQueue = new Queue <byte[]>(); client = tcpClient; ns = client.GetStream(); HeaderArray h_ = new HeaderArray(); unsafe { for (int i = 0; i < Header_Array.Length; i++) { h_.header[i] = Header_Array[i]; } } sendSP = new SendSP { header = new Header { header = h_, length = (UInt16)Marshal.SizeOf(typeof(StatusPacket)), type = 1 } }; sendVP = new SendVP { header = new Header { header = h_, length = (UInt16)Marshal.SizeOf(typeof(VesselPacket)), type = 2 } }; sendODPHeader = new Header { header = h_, type = 3 }; new Thread(new ThreadStart(RunRecieve)).Start(); new Thread(new ThreadStart(RunWrite)).Start(); }
/// <summary> /// Enumerates the <see cref="IHeaderArray"/> collection from file. /// </summary> /// <param name="file"> /// The file from which to read arrays. /// </param> /// <returns> /// A <see cref="IHeaderArray"/> collection from the file. /// </returns> public override IEnumerable <IHeaderArray> ReadArrays(FilePath file) { if (file is null) { throw new ArgumentNullException(nameof(file)); } using (ZipArchive archive = ZipFile.Open(file, ZipArchiveMode.Read)) { foreach (ZipArchiveEntry entry in archive.Entries) { yield return(HeaderArray.Deserialize(new StreamReader(entry.Open()).ReadToEnd())); } } }
private IEnumerable <IHeaderArray> BuildHeaderArrays([NotNull] FilePath file) { HeaderArrayFile arrayFile = HeaderArrayFile.BinaryReader.Read(file); // Variable information. int[] countOfComponentsInVariable = arrayFile["VNCP"].As <int>().Values.ToArray(); // Endogenous variable components and information. int[] pointersToCumulative = arrayFile["PCUM"].As <int>().Values.ToArray(); int[] countInCumulative = arrayFile["CMND"].As <int>().Values.ToArray(); float[] cumulativeResults = arrayFile["CUMS"].As <float>().Values.ToArray(); // Exogenous variable components and list of positions (where OREX != array.Length). int[] countOfExogenous = arrayFile["OREX"].As <int>().Values.ToArray(); int[] positionsOfExogenous = arrayFile["OREL"].As <int>().Values.ToArray(); // Shocked variable information int[] numberOfShockedComponents = arrayFile["SHCK"].As <int>().Values.ToArray(); int[] pointersToShockValues = arrayFile["PSHK"].As <int>().Values.ToArray(); int[] positionsOfShockValues = arrayFile["SHCL"].As <int>().Values.ToArray(); float[] shockValues = arrayFile["SHOC"].As <float>().Values.ToArray(); return (BuildSolutionArrays(arrayFile).Where(x => x.IsBacksolvedOrCondensed) .OrderBy(x => x.VariableIndex) .Select(BuildNextArray)); // Local method here to limit passing arrays as parameters. IHeaderArray BuildNextArray(SolutionArray array, int index) { float[] values = new float[array.Count]; // When the array is condensed/backsolved and the pointer is empty, its exogenous. int pointer = pointersToCumulative[index] - 1; if (pointer != -1) { Array.Copy(cumulativeResults, pointer, values, 0, countInCumulative[index]); } ShiftExogenous(values); Shocks(values); return (HeaderArray <float> .Create( array.Name, array.Name, array.Description, HeaderArrayType.RE, array.Sets.Select(x => x.Value.Count).Concat(Enumerable.Repeat(1, 7)).Take(7), values, array.Sets)); // Shifts existing entries to their appropriate positions to create gaps for exogenous values. void ShiftExogenous(float[] inputArray) { if (array.Count == countOfExogenous[index]) { Array.Clear(inputArray, 0, inputArray.Length); return; } float[] withGaps = inputArray; int nextValidPosition = 0; for (int i = 0; i < index; i++) { if (countOfExogenous[i] != countOfComponentsInVariable[i]) { nextValidPosition += countOfExogenous[i]; } } for (int i = 0; i < countOfExogenous[index]; i++) { int position = positionsOfExogenous[nextValidPosition + i] - 1; Array.Copy(withGaps, position, withGaps, position + 1, withGaps.Length - position - 1); withGaps[position] = default(float); } } // Adds shocks to open positions to a copy of the input array. void Shocks(float[] inputArray) { float[] withShocks = inputArray; int shockedCount = numberOfShockedComponents[index]; if (shockedCount == 0) { return; } int shockPointer = pointersToShockValues[index] - 1; int nextValidPosition = 0; for (int i = 0; i < index - 1; i++) { if (numberOfShockedComponents[i] != countOfComponentsInVariable[i]) { nextValidPosition += numberOfShockedComponents[i]; } } for (int i = 0; i < shockedCount; i++) { int position = array.Count == shockedCount ? i : positionsOfShockValues[nextValidPosition + i] - 1; float value = shockValues[shockPointer + i]; withShocks[position] = value; } } } }
private static IHeaderArray ReadNext([NotNull] BinaryReader reader) { string header = GetHeader(reader); if (header == "ADRV") { } (string description, HeaderArrayStorage storage, HeaderArrayType type, int[] dimensions, int count) = GetMetadata(reader); switch (type) { case HeaderArrayType.C1: { // Corner case wherein the string array is really an array of single characters. if (dimensions[1] == 1) { char[] values = GetOneDimensionalArray(reader, storage, count, (data, index, length) => (char)data[index]); return(HeaderArray <char> .Create(header, header, description, type, dimensions, values)); } else { string[] values = GetOneDimensionalArray(reader, storage, count, (data, index, length) => Encoding.ASCII.GetString(data, index, length).Trim('\u0000', '\u0002', '\u0020')); return(HeaderArray <string> .Create(header, header, description, type, dimensions, values)); } } case HeaderArrayType.I2: { int[] values = GetTwoDimensionalArray(reader, storage, count, BitConverter.ToInt32); return(HeaderArray <int> .Create(header, header, description, type, dimensions, values)); } case HeaderArrayType.R2: { float[] values = GetTwoDimensionalArray(reader, storage, count, BitConverter.ToSingle); return(HeaderArray <float> .Create(header, header, description, type, dimensions, values)); } case HeaderArrayType.RE: { (string coefficient, KeyValuePair <string, IImmutableList <string> >[] sets)temp = ReadSets(reader, dimensions); string coefficient = temp.coefficient; KeyValuePair <string, IImmutableList <string> >[] sets = temp.sets; float[] results = GetArrayWithSets(reader, storage, count, BitConverter.ToSingle); return(HeaderArray <float> .Create(header, coefficient, description, type, dimensions, results, sets.ToImmutableArray())); } default: { throw new DataValidationException("An unknown header array type was encountered.", "1C, RE, 2I, 2R", type); } } }