/// <summary> /// This method converts the given array of time series values (array of double precision /// floats) to a BLOB (byte array). It also sets the computes the checksum from the resultant /// BLOB, and then sets the Checksum and ValueBlob properties of the given ITimeSeriesTrace /// object accordingly. /// </summary> /// <param name="valueArray">The array of time series values to convert into a BLOB</param> /// <param name="compressionCode">a generation number that indicates what compression technique to use</param> /// <param name="traceObject">object whose TraceNumber property will be used to compute the checksum, /// and whose properties will be assigned by this method</param> /// <returns>The BLOB that is created from valueArray</returns> public static unsafe byte[] ConvertArrayToBlobRegular( double[] valueArray, int compressionCode, ITimeSeriesTrace traceObject) { // The number of bytes required for the BLOB int nBin = traceObject.TimeStepCount * sizeof(double); // Allocate an array for the BLOB Byte[] blobData = new Byte[nBin]; // Copy the array of doubles that was passed to the method into the byte array. // The byte array becomes the BLOB. Buffer.BlockCopy(valueArray, 0, blobData, 0, nBin); // Compute the checksum using the uncompressed BLOB. During development, it was // demonstrated that the checksum would be computed faster on the compressed BLOB. // However, this could make it difficult to upgrade the compression algorithm in the // future, because the checksum value would be dependent on the compression algorithm. Byte[] checksum = ComputeTraceChecksum(traceObject.TraceNumber, blobData); Boolean checksumChanged = (MurmurHash.ByteArraysAreEqual(traceObject.Checksum, checksum) == false); // If the checksum did not change, then we will not assign any properties to the traceObject. // The result will be that we will return the original ValueBlob. If the checksum did change, // then we compute a new compressed ValueBlob and assign the new values. if (checksumChanged) { traceObject.Checksum = checksum; // the BLOB is stored in a compressed form, so our last step is to compress it traceObject.ValueBlob = CompressBlob(blobData, compressionCode); } return(traceObject.ValueBlob); }
/// <summary> /// This method converts the given array of time series values (date/value pairs stored in /// TSDateValueStruct) to a BLOB (byte array). It also sets the computes the checksum from the /// resultant BLOB, and then sets the Checksum and ValueBlob properties of the given /// ITimeSeriesTrace object accordingly. /// </summary> /// <param name="dateValueArray">The array of time series values to convert into a BLOB</param> /// <param name="compressionCode">a generation number that indicates what compression technique to use</param> /// <param name="traceObject">object whose TraceNumber property will be used to compute the checksum, /// and whose properties will be assigned by this method</param> /// <returns>The BLOB that is created from dateValueArray</returns> public static unsafe byte[] ConvertArrayToBlobIrregular( TSDateValueStruct[] dateValueArray, int compressionCode, ITimeSeriesTrace traceObject) { // The number of bytes required for the BLOB int nBin = traceObject.TimeStepCount * sizeof(TSDateValueStruct); // Allocate an array for the BLOB Byte[] blobData = new Byte[nBin]; // MemoryStream and BinaryWriter objects enable copying of data to the BLOB using (MemoryStream blobStream = new MemoryStream(blobData)) using (BinaryWriter blobWriter = new BinaryWriter(blobStream)) { // Loop through the entire array for (int i = 0; i < traceObject.TimeStepCount; i++) { // write the value to the BLOB as DATE followed by VALUE blobWriter.Write(dateValueArray[i].Date.ToBinary()); blobWriter.Write(dateValueArray[i].Value); } } // Compute the checksum using the uncompressed BLOB. During development, it was // demonstrated that the checksum would be computed faster on the compressed BLOB. // However, this could make it difficult to upgrade the compression algorithm in the // future, because the checksum value would be dependent on the compression algorithm. Byte[] checksum = ComputeTraceChecksum(traceObject.TraceNumber, blobData); Boolean checksumChanged = (MurmurHash.ByteArraysAreEqual(traceObject.Checksum, checksum) == false); // If the checksum did not change, then we will not assign any properties to the traceObject. // The result will be that we will return the original ValueBlob. If the checksum did change, // then we compute a new compressed ValueBlob and assign the new values. if (checksumChanged) { traceObject.Checksum = checksum; // the BLOB is stored in a compressed form, so our last step is to compress it traceObject.ValueBlob = CompressBlob(blobData, compressionCode); } return(traceObject.ValueBlob); }