/// <summary>
/// Gets the first code of measurement value class.
/// </summary>
/// <param name="mvClass">The measurement value class.</param>
/// <returns></returns>
public static MVCode GetFirstCodeOfClass(MVClass mvClass)
{
IEnumerator <MVCode> it = GetCodesOfClass(mvClass);
if (null == it)
{
return(MVCode.INVALID);
}
it.MoveNext();
return(it.Current);
}
/// <summary>
/// Modifies the MVCode collection with specified MVCodes (given as string list).
/// </summary>
/// <param name="mvCodes">MVCode collection</param>
/// <param name="itemsToProcess">Items to add or remove</param>
/// <param name="adding">Given items should be added (true) or removed (false)</param>
private static void Modify(IList <MVCode> mvCodes, string itemsToProcess, bool adding)
{
if (null == mvCodes || null == itemsToProcess)
{
return;
}
string[] items = itemsToProcess.Split(new char[] { ',', ';', '|' }, StringSplitOptions.RemoveEmptyEntries);
foreach (string item in items)
{
MVCode mvCode = MVCodeHelper.ParseSafe(item);
MVClass mvClass = MVClassHelper.ParseSafe(item);
if (MVCode.INVALID != mvCode)
{
if (adding && !mvCodes.Contains(mvCode))
{
mvCodes.Add(mvCode);
}
if (!adding && mvCodes.Contains(mvCode))
{
mvCodes.Remove(mvCode);
}
}
if (MVClass.INVALID != mvClass)
{
IEnumerator <MVCode> enumerator = MVEnumerator.GetCodesOfClass(mvClass);
while (enumerator.MoveNext())
{
MVCode current = enumerator.Current;
if (current == MVCode.INVALID)
{
continue;
}
if (adding && !mvCodes.Contains(current))
{
mvCodes.Add(current);
}
if (!adding && mvCodes.Contains(current))
{
mvCodes.Remove(current);
}
}
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="MVClassOrMVCode" /> class.
/// </summary>
/// <param name="mvClass">The MVClass.</param>
/// <param name="mvCode">The MVCode (optional, may be null).</param>
public MVClassOrMVCode(MVClass mvClass, MVCode?mvCode = null)
{
this.MVClass = mvClass;
this.MVCode = mvCode;
}
/// <summary>
/// Determines whether measurement value code is member of the specified mv class.
/// </summary>
/// <param name="mvCode">The measurement value code.</param>
/// <param name="mvClass">The measurement value class.</param>
/// <returns>
/// <c>true</c> if is member of [the specified measurement value class; otherwise, <c>false</c>.
/// </returns>
public static bool IsMemberOf(MVCode mvCode, MVClass mvClass)
{
switch (mvClass)
{
case MVClass.Temperature:
return(Enumerable.Contains(MembersTemperature, mvCode));
case MVClass.RelativeHumidity:
return(Enumerable.Contains(MembersRelativeHumidity, mvCode));
case MVClass.Velocity:
return(Enumerable.Contains(MembersVelocity, mvCode));
case MVClass.StdVelocity:
return(Enumerable.Contains(MembersStdVelocity, mvCode));
case MVClass.CO2:
return(Enumerable.Contains(MembersCO2, mvCode));
case MVClass.CO2Raw:
return(Enumerable.Contains(MembersCO2Raw, mvCode));
case MVClass.O2:
return(Enumerable.Contains(MembersO2, mvCode));
case MVClass.WaterVaporPartialPressure:
return(Enumerable.Contains(MembersWaterVaporPartialPressure, mvCode));
case MVClass.DewPoint:
return(Enumerable.Contains(MembersDewPoint, mvCode));
case MVClass.WetBulb:
return(Enumerable.Contains(MembersWetBulb, mvCode));
case MVClass.AbsoluteHumidity:
return(Enumerable.Contains(MembersAbsoluteHumidity, mvCode));
case MVClass.MixingRatio:
return(Enumerable.Contains(MembersMixingRatio, mvCode));
case MVClass.Enthalpy:
return(Enumerable.Contains(MembersEnthalpy, mvCode));
case MVClass.DewPointOrFrostPoint:
return(Enumerable.Contains(MembersDewPointOrFrostPoint, mvCode));
case MVClass.WaterActivity:
return(Enumerable.Contains(MembersWaterActivity, mvCode));
case MVClass.PercentSaturation:
return(Enumerable.Contains(MembersPercentSaturation, mvCode));
case MVClass.VolumeConcentration:
return(Enumerable.Contains(MembersVolumeConcentration, mvCode));
case MVClass.WaterContent:
return(Enumerable.Contains(MembersWaterContent, mvCode));
case MVClass.SpecificMassFlow:
return(Enumerable.Contains(MembersSpecificMassFlow, mvCode));
case MVClass.MassFlow:
return(Enumerable.Contains(MembersMassFlow, mvCode));
case MVClass.StdVolumetricFlow:
return(Enumerable.Contains(MembersStdVolumetricFlow, mvCode));
case MVClass.VolumetricFlow:
return(Enumerable.Contains(MembersVolumetricFlow, mvCode));
case MVClass.VolumetricConsumption:
return(Enumerable.Contains(MembersVolumetricConsumption, mvCode));
case MVClass.VolumetricConsumptionTotal:
return(Enumerable.Contains(MembersVolumetricConsumptionTotal, mvCode));
case MVClass.Pressure:
return(Enumerable.Contains(MembersPressure, mvCode));
case MVClass.Resistance:
return(Enumerable.Contains(MembersResistance, mvCode));
case MVClass.Current:
return(Enumerable.Contains(MembersCurrent, mvCode));
case MVClass.Frequency:
return(Enumerable.Contains(MembersFrequency, mvCode));
case MVClass.Voltage:
return(Enumerable.Contains(MembersVoltage, mvCode));
case MVClass.Diameter:
return(Enumerable.Contains(MembersDiameter, mvCode));
case MVClass.FilterContamination:
return(Enumerable.Contains(MembersFilterContamination, mvCode));
case MVClass.LevelIndicator:
return(Enumerable.Contains(MembersLevelIndicator, mvCode));
case MVClass.DifferentialPressure:
return(Enumerable.Contains(MembersDifferentialPressure, mvCode));
}
return(false);
}
/// <summary>
/// Gets the codes of measurement value class.
/// </summary>
/// <param name="mvClass">The measurement value class.</param>
/// <returns></returns>
public static IEnumerator <MVCode> GetCodesOfClass(MVClass mvClass)
{
switch (mvClass)
{
case MVClass.INVALID:
yield return(MVCode.INVALID);
break;
case MVClass.Temperature:
foreach (MVCode mvCode in MembersTemperature)
{
yield return(mvCode);
}
break;
case MVClass.RelativeHumidity:
foreach (MVCode mvCode in MembersRelativeHumidity)
{
yield return(mvCode);
}
break;
case MVClass.Velocity:
foreach (MVCode mvCode in MembersVelocity)
{
yield return(mvCode);
}
break;
case MVClass.StdVelocity:
foreach (MVCode mvCode in MembersStdVelocity)
{
yield return(mvCode);
}
break;
case MVClass.CO2:
foreach (MVCode mvCode in MembersCO2)
{
yield return(mvCode);
}
break;
case MVClass.CO2Raw:
foreach (MVCode mvCode in MembersCO2Raw)
{
yield return(mvCode);
}
break;
case MVClass.O2:
foreach (MVCode mvCode in MembersO2)
{
yield return(mvCode);
}
break;
case MVClass.WaterVaporPartialPressure:
foreach (MVCode mvCode in MembersWaterVaporPartialPressure)
{
yield return(mvCode);
}
break;
case MVClass.DewPoint:
foreach (MVCode mvCode in MembersDewPoint)
{
yield return(mvCode);
}
break;
case MVClass.WetBulb:
foreach (MVCode mvCode in MembersWetBulb)
{
yield return(mvCode);
}
break;
case MVClass.AbsoluteHumidity:
foreach (MVCode mvCode in MembersAbsoluteHumidity)
{
yield return(mvCode);
}
break;
case MVClass.MixingRatio:
foreach (MVCode mvCode in MembersMixingRatio)
{
yield return(mvCode);
}
break;
case MVClass.Enthalpy:
foreach (MVCode mvCode in MembersEnthalpy)
{
yield return(mvCode);
}
break;
case MVClass.DewPointOrFrostPoint:
foreach (MVCode mvCode in MembersDewPointOrFrostPoint)
{
yield return(mvCode);
}
break;
case MVClass.WaterActivity:
foreach (MVCode mvCode in MembersWaterActivity)
{
yield return(mvCode);
}
break;
case MVClass.PercentSaturation:
foreach (MVCode mvCode in MembersPercentSaturation)
{
yield return(mvCode);
}
break;
case MVClass.VolumeConcentration:
foreach (MVCode mvCode in MembersVolumeConcentration)
{
yield return(mvCode);
}
break;
case MVClass.WaterContent:
foreach (MVCode mvCode in MembersWaterContent)
{
yield return(mvCode);
}
break;
case MVClass.SpecificMassFlow:
foreach (MVCode mvCode in MembersSpecificMassFlow)
{
yield return(mvCode);
}
break;
case MVClass.MassFlow:
foreach (MVCode mvCode in MembersMassFlow)
{
yield return(mvCode);
}
break;
case MVClass.StdVolumetricFlow:
foreach (MVCode mvCode in MembersStdVolumetricFlow)
{
yield return(mvCode);
}
break;
case MVClass.VolumetricFlow:
foreach (MVCode mvCode in MembersVolumetricFlow)
{
yield return(mvCode);
}
break;
case MVClass.VolumetricConsumption:
foreach (MVCode mvCode in MembersVolumetricConsumption)
{
yield return(mvCode);
}
break;
case MVClass.VolumetricConsumptionTotal:
foreach (MVCode mvCode in MembersVolumetricConsumptionTotal)
{
yield return(mvCode);
}
break;
case MVClass.Pressure:
foreach (MVCode mvCode in MembersPressure)
{
yield return(mvCode);
}
break;
case MVClass.Resistance:
foreach (MVCode mvCode in MembersResistance)
{
yield return(mvCode);
}
break;
case MVClass.Current:
foreach (MVCode mvCode in MembersCurrent)
{
yield return(mvCode);
}
break;
case MVClass.Frequency:
foreach (MVCode mvCode in MembersFrequency)
{
yield return(mvCode);
}
break;
case MVClass.Voltage:
foreach (MVCode mvCode in MembersVoltage)
{
yield return(mvCode);
}
break;
case MVClass.Diameter:
foreach (MVCode mvCode in MembersDiameter)
{
yield return(mvCode);
}
break;
case MVClass.FilterContamination:
foreach (MVCode mvCode in MembersFilterContamination)
{
yield return(mvCode);
}
break;
case MVClass.LevelIndicator:
foreach (MVCode mvCode in MembersLevelIndicator)
{
yield return(mvCode);
}
break;
case MVClass.DifferentialPressure:
foreach (MVCode mvCode in MembersDifferentialPressure)
{
yield return(mvCode);
}
break;
}
}
