/// <summary>
/// This method converts a List of TimeSeriesValue objects into a BLOB (byte array) of
/// time series values and computes a checksum from the BLOB. This method assigns the new values
/// of the ValueBlob, Checksum, EndDate, and TimeStepCount to the object given in the traceObject
/// parameter. The TraceNumber property of the traceObject parameter must be set before calling
/// this method.
///
/// The entire List is converted into the BLOB--i.e., the method does not take any
/// parameters for limiting the size of the List that is created. This method will
/// throw exceptions if the meta-parameters that are passed in are not consistent
/// with the List of TimeSeriesValue objects.
/// </summary>
/// <param name="timeStepUnit">TSDateCalculator.TimeStepUnitCode value for
/// Minute, Hour, Day, Week, Month, Year, or Irregular</param>
/// <param name="timeStepQuantity">The number of the given unit that defines the time step.
/// For instance, if the time step is 6 hours long, then this value is 6.</param>
/// <param name="timeStepCount">The number of time steps stored in the BLOB</param>
/// <param name="blobStartDate">Date of the first time step in the BLOB</param>
/// <param name="blobEndDate">Date of the last time step in the BLOB</param>
/// <param name="dateValueList">A List of TimeSeriesValue objects that will be converted to a BLOB</param>
/// <param name="traceObject">an object which contains the a TraceNumber property that is used to
/// compute the checksum. The computed BLOB and checksum are both saved to the appropriate properties
/// of this object.</param>
/// <param name="compressionCode">a generation number that indicates what compression technique to use</param>
/// <returns>The BLOB (byte array) of time series values that was created from dateValueList</returns>
public byte[] ConvertListToBlobWithChecksum(
TSDateCalculator.TimeStepUnitCode timeStepUnit, short timeStepQuantity,
int timeStepCount, DateTime blobStartDate, DateTime blobEndDate,
List <TimeSeriesValue> dateValueList,
ITimeSeriesTrace traceObject, out int compressionCode)
{
// Error checks
if (dateValueList.Count != timeStepCount)
{
throw new TSLibraryException(ErrCode.Enum.Checksum_Improper_Count);
}
if (dateValueList[0].Date != blobStartDate)
{
throw new TSLibraryException(ErrCode.Enum.Checksum_Improper_StartDate);
}
if (dateValueList.Last().Date != blobEndDate)
{
throw new TSLibraryException(ErrCode.Enum.Checksum_Improper_EndDate);
}
// When compressing, we always use the latest compression method
compressionCode = TSBlobCoder.currentCompressionCode;
// Assign properties to the Trace object
if (traceObject.EndDate != blobEndDate)
{
traceObject.EndDate = blobEndDate;
}
if (traceObject.TimeStepCount != timeStepCount)
{
traceObject.TimeStepCount = timeStepCount;
}
// Convert the List dateValueList into a BLOB.
if (timeStepUnit == TSDateCalculator.TimeStepUnitCode.Irregular)
{
// IRREGULAR TIME SERIES
// The method in TSBlobCoder can only process an array of TSDateValueStruct. Therefore
// we convert the List of objects to an Array of struct instances.
TSDateValueStruct[] dateValueArray = dateValueList.Select(tsv => (TSDateValueStruct)tsv).ToArray();
// Let the method in TSBlobCoder class do all the work
TSBlobCoder.ConvertArrayToBlobIrregular(dateValueArray, compressionCode, traceObject);
}
else
{
// REGULAR TIME SERIES
// The method in TSBlobCoder can only process an array of double values. Therefore
// we convert the List of date/value objects to an Array values.
double[] valueArray = dateValueList.Select(dv => dv.Value).ToArray();
// Let the method in TSBlobCoder class do all the work
TSBlobCoder.ConvertArrayToBlobRegular(valueArray, compressionCode, traceObject);
}
return(traceObject.ValueBlob);
}
/// <summary>
/// This method prepares a new record for the trace table for an irregular time step series.
/// The method converts the given dateValueArray into the BLOB that is actually stored in
/// the table. The method computes the checksum of the trace, and computes a new checksum
/// for the parameters table to reflect the fact that a new trace has been added to the ensemble.
/// For both the insertion to the trace table and the update to the parameters table, this method
/// only stores changes in DataTable objects--nothing is changed in the database. In order for
/// the changes to be sent to the database, the method TSConnection.CommitNewTraceWrites must
/// be called after WriteTraceIrregular has been called for all new traces.
/// </summary>
/// <param name="id">identifying primary key value of the the parameters table for the record
/// that this trace belongs to</param>
/// <param name="doWriteToDB">true if the method should actually save the timeseries to the database</param>
/// <param name="tsImport">TSImport object into which the method will record values that it has computed.
/// If this parameter is null, then the method will skip the recording of such paramters to an object.</param>
/// <param name="traceNumber">number of the trace to write</param>
/// <param name="dateValueArray">The array of values to be written to the database</param>
public unsafe void WriteTraceIrregular(int id,
bool doWriteToDB, TSImport tsImport,
int traceNumber,
TSDateValueStruct[] dateValueArray)
{
// Initialize class fields other than the BLOB of data values
if (!IsInitialized)
{
Initialize(id, true);
}
// This method can only process irregular-time-step series
if (TimeStepUnit != TSDateCalculator.TimeStepUnitCode.Irregular)
{
throw new TSLibraryException(ErrCode.Enum.Record_Not_Irregular,
String.Format("The method can only process irregular time series, but" +
"the record with Id {0} is regular.", id));
}
// Create a trace object
ITimeSeriesTrace traceObject = new TSTrace
{
TraceNumber = traceNumber,
TimeStepCount = dateValueArray.Count(),
EndDate = dateValueArray.Any() ? dateValueArray.Last().Date : BlobStartDate
};
if (tsImport != null)
{
tsImport.TraceList.Add(traceObject);
}
else
{
TraceList.Add(traceObject);
}
// Convert the array of double values into a byte array...a BLOB
TSBlobCoder.ConvertArrayToBlobIrregular(dateValueArray, CompressionCode, traceObject);
// Create a new record for the trace table
// (but for now it is only stored in a DataTable object)
if (doWriteToDB)
{
WriteTrace(traceObject);
}
// Compute a new checksum for the parameters table
// (but for now it is only stored in a DataTable object)
UpdateParametersChecksum(doWriteToDB, tsImport);
}