/// <summary> This method takes in integer values for the year and month and day
/// and performs validations, it then sets the value in the object
/// formatted as an HL7 date value with year and month and day precision (YYYYMMDD).
/// </summary>
public virtual void setYearMonthDayPrecision(int yr, int mnth, int dy)
{
try
{
//ensure that the year field is four digits long
if (Convert.ToString(yr).Length != 4)
{
String msg = "The input year value must be four digits long";
DataTypeException e = new DataTypeException(msg);
throw e;
}
GregorianCalendar cal = new GregorianCalendar();
//validate the input month/day combination
new DateTime(yr, mnth, dy, cal);
year = yr;
month = mnth;
day = dy;
value_Renamed = Convert.ToString(yr) + DataTypeUtil.preAppendZeroes(mnth, 2) + DataTypeUtil.preAppendZeroes(dy, 2);
}
catch (DataTypeException e)
{
throw e;
}
catch (Exception e)
{
throw new DataTypeException("An unexpected exception ocurred", e);
}
}
/// <summary>
/// This method takes in integer values for the hour and minute and performs validations,
/// it then sets the value field formatted as an HL7 time value
/// with hour and minute precision (HHMM).
/// </summary>
public virtual void SetHourMinutePrecision(int hr, int min)
{
try
{
HourPrecision = hr;
// validate input minute value
if ((min < 0) || (min > 59))
{
var msg = "The minute value of the TM datatype must be >=0 and <=59";
var e = new DataTypeException(msg);
throw e;
}
Minute = min;
Second = 0;
FractSecond = 0;
GMTOffset = 0;
// Here the offset is not defined, we should omit showing it in the
// return value from the getValue() method
omitOffsetFg = 'y';
valueRenamed = valueRenamed + DataTypeUtil.PreAppendZeroes(min, 2);
}
catch (DataTypeException e)
{
// TODO: this will remove the stack trace - is that correct?
throw e;
}
catch (Exception e)
{
throw new DataTypeException(e.Message);
}
}
} //end constructor
/// <summary> This method takes in integer values for the hour and minute and performs validations,
/// it then sets the value field formatted as an HL7 time value
/// with hour and minute precision (HHMM).
/// </summary>
public virtual void setHourMinutePrecision(int hr, int min)
{
try
{
this.HourPrecision = hr;
//validate input minute value
if ((min < 0) || (min > 59))
{
System.String msg = "The minute value of the TM datatype must be >=0 and <=59";
DataTypeException e = new DataTypeException(msg);
throw e;
} //end if
minute = min;
second = 0;
fractionOfSec = 0;
offSet = 0;
//Here the offset is not defined, we should omit showing it in the
//return value from the getValue() method
omitOffsetFg = 'y';
value_Renamed = value_Renamed + DataTypeUtil.preAppendZeroes(min, 2);
}
//end try
catch (DataTypeException e)
{
throw e;
}
//end catch
catch (System.Exception e)
{
throw new DataTypeException(e.Message);
} //end catch
}
public void DataTypeException_Constructors()
{
var ex1 = new DataTypeException();
Assert.IsNull(ex1.InnerException);
var ex2 = new DataTypeException("foo");
Assert.AreEqual("foo", ex2.Message);
Assert.IsNull(ex2.InnerException);
Assert.IsTrue(ex2.ToString().Contains("foo"));
var iex = new Exception();
var ex3 = new DataTypeException("foo", iex);
Assert.AreEqual("foo", ex3.Message);
Assert.AreSame(iex, ex3.InnerException);
Assert.IsTrue(ex3.ToString().Contains("foo"));
AssertEx.ThrowsException <ArgumentNullException>(() => new DataTypeException(default(DataTypeError)), ex => Assert.AreEqual("error", ex.ParamName));
var err = new DataTypeError(typeof(int), "bar", new[] { typeof(List <int>) });
var ex4 = new DataTypeException(err);
Assert.AreSame(err, ex4.Error);
Assert.IsTrue(ex4.ToString().Contains("bar"));
}
/// <summary> This method takes in integer values for the year and month and performs validations,
/// it then sets the value field formatted as an HL7 date
/// value with year and month precision (YYYYMM).
/// Note: The first month = 1 = January.
/// </summary>
public virtual void SetYearMonthPrecision(int yr, int mnth)
{
try
{
// ensure that the year field is four digits long
if (Convert.ToString(yr).Length != 4)
{
var msg = "The input year value must be four digits long";
var e = new DataTypeException(msg);
throw e;
}
var cal = new GregorianCalendar();
// validate the input month
new DateTime(yr, mnth, 1, cal);
Year = yr;
Month = mnth;
Day = 0;
valueRenamed = Convert.ToString(yr) + DataTypeUtil.PreAppendZeroes(mnth, 2);
}
catch (DataTypeException e)
{
throw e;
}
catch (Exception e)
{
throw new DataTypeException("An unexpected exception occurred", e);
}
}
/// <summary> This method takes in integer values for the year and month and day
/// and performs validations, it then sets the value in the object
/// formatted as an HL7 date value with year and month and day precision (YYYYMMDD).
/// </summary>
public virtual void setYearMonthDayPrecision(int yr, int mnth, int dy)
{
try
{
System.Globalization.GregorianCalendar cal = new System.Globalization.GregorianCalendar();
SupportClass.CalendarManager.manager.Clear(cal);
//ensure that the year field is four digits long
if (System.Convert.ToString(yr).Length != 4)
{
System.String msg = "The input year value must be four digits long";
DataTypeException e = new DataTypeException(msg);
throw e;
}
//validate the input month/day combination
SupportClass.CalendarManager.manager.Set(cal, yr, (mnth - 1), dy);
SupportClass.CalendarManager.manager.GetDateTime(cal); //for error detection
year = yr;
month = mnth;
day = dy;
value_Renamed = System.Convert.ToString(yr) + DataTypeUtil.preAppendZeroes(mnth, 2) + DataTypeUtil.preAppendZeroes(dy, 2);
}
catch (DataTypeException e)
{
throw e;
}
catch (System.Exception e)
{
throw new DataTypeException("An unexpected exception ocurred", e);
}
}
/// <summary>
/// This method takes in integer values for the hour, minute, seconds, and fractional seconds
/// (going to the ten thousandths precision).
/// The method performs validations and then sets the value field formatted as an
/// HL7 time value with a precision that starts from the hour and goes down to the ten thousandths
/// of a second (HHMMSS.SSSS).
/// Note: all of the precisions from tenths down to ten thousandths of a
/// second are optional. If the precision goes below ten thousandths of a second then the second
/// value will be rounded to the nearest ten thousandths of a second.
/// </summary>
public virtual void SetHourMinSecondPrecision(int hr, int min, float sec)
{
try
{
SetHourMinutePrecision(hr, min);
// multiply the seconds input value by 10000 and round the result
// then divide the number by ten thousand and store it back.
// This will round the fractional seconds to the nearest ten thousandths
var secMultRound = (int)Math.Round((double)(10000F * sec));
sec = secMultRound / 10000F;
// Now store the second and fractional component
Second = (int)Math.Floor(sec);
// validate input seconds value
if ((Second < 0) || (Second >= 60))
{
var msg = "The (rounded) second value of the TM datatype must be >=0 and <60";
var e = new DataTypeException(msg);
throw e;
}
var fractionOfSecInt = (int)(secMultRound - (Second * 10000));
FractSecond = fractionOfSecInt / 10000F;
var fractString = string.Empty;
// Now convert the fractionOfSec field to a string without the leading zero
if (FractSecond != 0.0F)
{
fractString = FractSecond.ToString().Substring(1);
}
// Now update the value field
GMTOffset = 0;
// Here the offset is not defined, we should omit showing it in the
// return value from the getValue() method
omitOffsetFg = 'y';
valueRenamed = valueRenamed + DataTypeUtil.PreAppendZeroes(Second, 2) + fractString;
}
catch (DataTypeException e)
{
// TODO: this will remove the stack trace - is that correct?
throw e;
}
catch (Exception e)
{
throw new DataTypeException("An unexpected exception occurred", e);
}
}
public void DataTypeException_Serialize()
{
var err = new DataTypeError(typeof(int), "bar", new[] { typeof(List <int>) });
var ex = new DataTypeException(err);
var ms = new MemoryStream();
new BinaryFormatter().Serialize(ms, ex);
ms.Position = 0;
var res = (DataTypeException) new BinaryFormatter().Deserialize(ms);
Assert.AreEqual(err.Message, res.Error.Message);
Assert.AreEqual(err.Type, res.Error.Type);
AssertEx.AreSequenceEqual(err.Stack, res.Error.Stack);
}
/// <summary> This method takes in integer values for the hour, minute, seconds, and fractional seconds
/// (going to the tenthousandths precision).
/// The method performs validations and then sets the value field formatted as an
/// HL7 time value with a precision that starts from the hour and goes down to the tenthousandths
/// of a second (HHMMSS.SSSS).
/// Note: all of the precisions from tenths down to tenthousandths of a
/// second are optional. If the precision goes below tenthousandths of a second then the second
/// value will be rounded to the nearest tenthousandths of a second.
/// </summary>
public virtual void setHourMinSecondPrecision(int hr, int min, float sec)
{
try
{
this.setHourMinutePrecision(hr, min);
//multiply the seconds input value by 10000 and round the result
//then divide the number by tenthousand and store it back.
//This will round the fractional seconds to the nearest tenthousandths
int secMultRound = (int)System.Math.Round((double)(10000F * sec));
sec = secMultRound / 10000F;
//Now store the second and fractional component
second = (int)System.Math.Floor(sec);
//validate input seconds value
if ((second < 0) || (second >= 60))
{
System.String msg = "The (rounded) second value of the TM datatype must be >=0 and <60";
DataTypeException e = new DataTypeException(msg);
throw e;
} //end if
int fractionOfSecInt = (int)(secMultRound - (second * 10000));
fractionOfSec = fractionOfSecInt / 10000F;
System.String fractString = "";
//Now convert the fractionOfSec field to a string without the leading zero
if (fractionOfSec != 0.0F)
{
fractString = (fractionOfSec.ToString()).Substring(1);
} //end if
//Now update the value field
offSet = 0;
//Here the offset is not defined, we should omit showing it in the
//return value from the getValue() method
omitOffsetFg = 'y';
value_Renamed = value_Renamed + DataTypeUtil.preAppendZeroes(second, 2) + fractString;
}
//end try
catch (DataTypeException e)
{
throw e;
}
//end catch
catch (System.Exception e)
{
throw new DataTypeException("An unexpected exception ocurred", e);
} //end catch
}
/// <summary> This method takes in integer values for the year and month and performs validations,
/// it then sets the value field formatted as an HL7 date
/// value with year and month precision (YYYYMM).
/// Note: The first month = 1 = January.
/// </summary>
public virtual void setYearMonthPrecision(int yr, int mnth)
{
try
{
System.Globalization.GregorianCalendar cal = new System.Globalization.GregorianCalendar();
SupportClass.CalendarManager.manager.Clear(cal);
//ensure that the year field is four digits long
if (System.Convert.ToString(yr).Length != 4)
{
System.String msg = "The input year value must be four digits long";
DataTypeException e = new DataTypeException(msg);
throw e;
}
//validate the input month
//GregorianCalendar cal = new GregorianCalendar(yr,(mnth-1),1);
SupportClass.CalendarManager.manager.Set(cal, yr, (mnth - 1), 1);
SupportClass.CalendarManager.manager.GetDateTime(cal); //for error detection
year = yr;
month = mnth;
day = 0;
value_Renamed = System.Convert.ToString(yr) + DataTypeUtil.preAppendZeroes(mnth, 2);
}
catch (DataTypeException e)
{
throw e;
}
catch (System.Exception e)
{
throw new DataTypeException("An unexpected exception ocurred", e);
}
}
/// <summary> This method takes in integer values for the year and month and day
/// and performs validations, it then sets the value in the object
/// formatted as an HL7 date value with year and month and day precision (YYYYMMDD).
/// </summary>
public virtual void setYearMonthDayPrecision(int yr, int mnth, int dy)
{
try
{
//ensure that the year field is four digits long
if (Convert.ToString(yr).Length != 4)
{
String msg = "The input year value must be four digits long";
DataTypeException e = new DataTypeException(msg);
throw e;
}
GregorianCalendar cal = new GregorianCalendar();
//validate the input month/day combination
new DateTime(yr, mnth, dy, cal);
year = yr;
month = mnth;
day = dy;
value_Renamed = Convert.ToString(yr) + DataTypeUtil.preAppendZeroes(mnth, 2) + DataTypeUtil.preAppendZeroes(dy, 2);
}
catch (DataTypeException e)
{
throw e;
}
catch (Exception e)
{
throw new DataTypeException("An unexpected exception ocurred", e);
}
}
internal TcAdsSymbolInfo CreateArrayElement(TcAdsSymbolInfo parentArrayInstance, TcAdsDataType parentArrayType, int subIndex)
{
if (parentArrayInstance == null)
{
throw new ArgumentNullException("arrayInstance");
}
if (parentArrayType == null)
{
throw new ArgumentNullException("parentArrayType");
}
TcAdsSymbolInfo info = null;
ITcAdsDataType baseType = parentArrayType.BaseType;
if (baseType == null)
{
DataTypeException innerException = new DataTypeException("Base type of Array '{0}' not defined!", parentArrayType);
throw new AdsSymbolException("Cannot create array element!", parentArrayInstance, innerException);
}
bool isBitType = parentArrayInstance.IsBitType;
ReadOnlyDimensionCollection dimensions = parentArrayType.Dimensions;
int elementSize = this.calcElementBaseSize(parentArrayInstance);
if (subIndex < parentArrayType.Dimensions.ElementCount)
{
info = new TcAdsSymbolInfo(this._parser, parentArrayInstance, subIndex)
{
size = (uint)elementSize,
typeEntryFlags = this.createElementTypeEntryFlags(parentArrayInstance, (TcAdsDataType)baseType),
flags = this.createElementSymbolFlags(parentArrayInstance, (TcAdsDataType)baseType),
dataTypeId = (baseType == null) ? AdsDatatypeId.ADST_BIGTYPE : baseType.DataTypeId
};
if (baseType != null)
{
info.typeName = baseType.Name;
info.arrayInfo = baseType.Dimensions.ToArray();
}
else
{
info.typeName = parentArrayType.BaseTypeName;
info.arrayInfo = null;
}
info.comment = parentArrayInstance.Comment;
this.calcArrayElementIndexGroupIndexOffset(subIndex, parentArrayInstance, elementSize, out info.indexGroup, out info.indexOffset);
string str = ArrayIndexConverter.SubIndexToIndexString(parentArrayType.Dimensions.LowerBounds, parentArrayType.Dimensions.UpperBounds, subIndex);
info.instancePath = parentArrayInstance.instancePath + str;
info.shortName = parentArrayInstance.shortName + str;
info.attributes = parentArrayInstance.attributes;
}
if ((subIndex == parentArrayType.Dimensions.ElementCount) && ((parentArrayType.Flags & (AdsDataTypeFlags.None | AdsDataTypeFlags.Oversample)) != AdsDataTypeFlags.None))
{
info = new TcAdsSymbolInfo(this._parser, parentArrayInstance, subIndex)
{
size = (uint)elementSize,
typeEntryFlags = this.createElementTypeEntryFlags(parentArrayInstance, (TcAdsDataType)baseType),
flags = this.createElementSymbolFlags(parentArrayInstance, (TcAdsDataType)baseType)
};
if (info.typeEntryFlags.HasFlag(AdsDataTypeFlags.None | AdsDataTypeFlags.Static))
{
info.indexGroup = 0xf019;
info.indexOffset = 0;
}
else
{
info.indexGroup = parentArrayInstance.indexGroup;
info.indexOffset = parentArrayInstance.indexOffset;
}
if (baseType != null)
{
info.dataTypeId = baseType.DataTypeId;
info.typeName = baseType.Name;
}
else
{
info.dataTypeId = AdsDatatypeId.ADST_BIGTYPE;
info.typeName = parentArrayType.BaseTypeName;
}
info.comment = parentArrayInstance.Comment;
string str2 = ArrayIndexConverter.OversamplingSubElementToString(subIndex);
info.instancePath = parentArrayInstance.instancePath + str2;
info.shortName = parentArrayInstance.shortName + str2;
if ((parentArrayType.Flags & (AdsDataTypeFlags.None | AdsDataTypeFlags.PropItem)) == (AdsDataTypeFlags.None | AdsDataTypeFlags.PropItem))
{
info.indexGroup = 0xf017;
info.indexOffset = parentArrayType.TypeHashValue;
}
info.attributes = parentArrayInstance.attributes;
}
return(info);
}
