using IStation.Epanet.Util;
|
|
namespace IStation.Epanet.Enums
|
{
|
|
public static class EnumsTxt
|
{
|
|
public static bool TryParse(string text, out Varwords result)
|
{
|
if (text.Match(Keywords.wr_DEMAND)) result = Varwords.DEMAND;
|
else if (text.Match(Keywords.wr_HEAD)) result = Varwords.HEAD;
|
else if (text.Match(Keywords.wr_GRADE)) result = Varwords.GRADE;
|
else if (text.Match(Keywords.wr_LEVEL)) result = Varwords.LEVEL;
|
else if (text.Match(Keywords.wr_PRESSURE)) result = Varwords.PRESSURE;
|
else if (text.Match(Keywords.wr_FLOW)) result = Varwords.FLOW;
|
else if (text.Match(Keywords.wr_STATUS)) result = Varwords.STATUS;
|
else if (text.Match(Keywords.wr_SETTING)) result = Varwords.SETTING;
|
else if (text.Match(Keywords.wr_POWER)) result = Varwords.POWER;
|
else if (text.Match(Keywords.wr_TIME)) result = Varwords.CLOCKTIME;
|
else if (text.Match(Keywords.wr_CLOCKTIME)) result = Varwords.CLOCKTIME;
|
else if (text.Match(Keywords.wr_FILLTIME)) result = Varwords.FILLTIME;
|
else if (text.Match(Keywords.wr_DRAINTIME)) result = Varwords.DRAINTIME;
|
else
|
{
|
result = (Varwords)(-1);
|
return false;
|
}
|
|
return true;
|
}
|
|
|
public static bool TryParse(string text, out Values result)
|
{
|
if (text.Match(Keywords.wr_ACTIVE)) result = Values.IS_ACTIVE;
|
else if (text.Match(Keywords.wr_CLOSED)) result = Values.IS_CLOSED;
|
// else if (text.Match("XXXX")) result = Rule.Values.IS_NUMBER;
|
else if (text.Match(Keywords.wr_OPEN)) result = Values.IS_OPEN;
|
else
|
{
|
result = (Values)(-1);
|
return false;
|
}
|
|
return true;
|
}
|
|
|
public static bool TryParse(this string text, out Rulewords result)
|
{
|
int index = text.FindMatch(
|
text,
|
Keywords.wr_AND,
|
Keywords.wr_ELSE,
|
string.Empty,
|
Keywords.wr_IF,
|
Keywords.wr_OR,
|
Keywords.wr_PRIORITY,
|
Keywords.wr_RULE,
|
Keywords.wr_THEN);
|
|
return (int)(result = (Rulewords)index) != -1;
|
}
|
|
public static bool TryParse(this string text, out Operators result)
|
{
|
text = text.Trim();
|
|
if (text.Equals(Keywords.wr_ABOVE, StringComparison.OrdinalIgnoreCase))
|
result = Operators.ABOVE;
|
else if (text.Equals(Keywords.wr_BELOW, StringComparison.OrdinalIgnoreCase))
|
result = Operators.BELOW;
|
else if (text == "=")
|
result = Operators.EQ;
|
else if (text == ">=")
|
result = Operators.GE;
|
else if (text == ">")
|
result = Operators.GT;
|
else if (text.Equals(Keywords.wr_IS, StringComparison.OrdinalIgnoreCase))
|
result = Operators.IS;
|
else if (text == "<=")
|
result = Operators.LE;
|
else if (text == "<")
|
result = Operators.LT;
|
else if (text == "<>")
|
result = Operators.NE;
|
else if (text.Equals(Keywords.wr_NOT, StringComparison.OrdinalIgnoreCase))
|
result = Operators.NOT;
|
else
|
{
|
result = (Operators)(-1);
|
return false;
|
}
|
|
return true;
|
}
|
|
public static bool TryParse(this string text, out Objects result)
|
{
|
if (text.Match(Keywords.wr_JUNC)) result = Objects.JUNC;
|
else if (text.Match(Keywords.w_RESERV)) result = Objects.RESERV;
|
else if (text.Match(Keywords.w_TANK)) result = Objects.TANK;
|
else if (text.Match(Keywords.w_PIPE)) result = Objects.PIPE;
|
else if (text.Match(Keywords.w_PUMP)) result = Objects.PUMP;
|
else if (text.Match(Keywords.w_VALVE)) result = Objects.VALVE;
|
else if (text.Match(Keywords.w_NODE)) result = Objects.NODE;
|
else if (text.Match(Keywords.w_LINK)) result = Objects.LINK;
|
else if (text.Match(Keywords.w_SYSTEM)) result = Objects.SYSTEM;
|
else
|
{
|
result = (Objects)(-1);
|
return false;
|
}
|
|
return true;
|
}
|
|
public static bool TryParse(this string text, out MixType result)
|
{
|
if (text.Match(Keywords.w_MIXED)) result = MixType.Mix1;
|
else if (text.Match(Keywords.w_2COMP)) result = MixType.Mix2;
|
else if (text.Match(Keywords.w_FIFO)) result = MixType.Fifo;
|
else if (text.Match(Keywords.w_LIFO)) result = MixType.Lifo;
|
else
|
{
|
result = (MixType)(-1);
|
return false;
|
}
|
|
return true;
|
}
|
|
public static string ParseStr(this MixType value)
|
{
|
switch (value)
|
{
|
case MixType.Fifo: return Keywords.w_FIFO;
|
case MixType.Lifo: return Keywords.w_LIFO;
|
case MixType.Mix1: return Keywords.w_MIXED;
|
case MixType.Mix2: return Keywords.w_2COMP;
|
default: return null;
|
}
|
}
|
|
public static bool TryParse(this string text, out FieldType result)
|
{
|
if (text.Match(Keywords.t_ELEV)) result = FieldType.ELEV;
|
else if (text.Match(Keywords.t_DEMAND)) result = FieldType.DEMAND;
|
else if (text.Match(Keywords.t_HEAD)) result = FieldType.HEAD;
|
else if (text.Match(Keywords.t_PRESSURE)) result = FieldType.PRESSURE;
|
else if (text.Match(Keywords.t_QUALITY)) result = FieldType.QUALITY;
|
else if (text.Match(Keywords.t_LENGTH)) result = FieldType.LENGTH;
|
else if (text.Match(Keywords.t_DIAM)) result = FieldType.DIAM;
|
else if (text.Match(Keywords.t_FLOW)) result = FieldType.FLOW;
|
else if (text.Match(Keywords.t_VELOCITY)) result = FieldType.VELOCITY;
|
else if (text.Match(Keywords.t_HEADLOSS)) result = FieldType.HEADLOSS;
|
else if (text.Match(Keywords.t_LINKQUAL)) result = FieldType.LINKQUAL;
|
else if (text.Match(Keywords.t_STATUS)) result = FieldType.STATUS;
|
else if (text.Match(Keywords.t_SETTING)) result = FieldType.SETTING;
|
else if (text.Match(Keywords.t_REACTRATE)) result = FieldType.REACTRATE;
|
else if (text.Match(Keywords.t_FRICTION)) result = FieldType.FRICTION;
|
else
|
{
|
result = (FieldType)(-1);
|
return false;
|
}
|
|
return true;
|
}
|
|
public static bool TryParse(this string text, out SourceType result)
|
{
|
if (text.Match(Keywords.w_CONCEN)) result = SourceType.Concen;
|
else if (text.Match(Keywords.w_FLOWPACED)) result = SourceType.FlowPaced;
|
else if (text.Match(Keywords.w_MASS)) result = SourceType.Mass;
|
else if (text.Match(Keywords.w_SETPOINT)) result = SourceType.SetPoint;
|
else
|
{
|
result = (SourceType)(-1);
|
return false;
|
}
|
|
return true;
|
}
|
|
public static string ReportStr(this StatusType value)
|
{
|
switch (value)
|
{
|
case StatusType.XHEAD: return Keywords.t_XHEAD;
|
case StatusType.TEMPCLOSED: return Keywords.t_TEMPCLOSED;
|
case StatusType.CLOSED: return Keywords.t_CLOSED;
|
case StatusType.OPEN: return Keywords.t_OPEN;
|
case StatusType.ACTIVE: return Keywords.t_ACTIVE;
|
case StatusType.XFLOW: return Keywords.t_XFLOW;
|
case StatusType.XFCV: return Keywords.t_XFCV;
|
case StatusType.XPRESSURE: return Keywords.t_XPRESSURE;
|
case StatusType.FILLING: return Keywords.t_FILLING;
|
case StatusType.EMPTYING: return Keywords.t_EMPTYING;
|
default: return null;
|
}
|
}
|
|
public static string ParseStr(this ControlType value)
|
{
|
switch (value)
|
{
|
case ControlType.HiLevel: return Keywords.w_ABOVE;
|
case ControlType.LowLevel: return Keywords.w_BELOW;
|
case ControlType.TimeOfDay: return Keywords.w_CLOCKTIME;
|
case ControlType.Timer: return Keywords.w_TIME;
|
default: return null;
|
}
|
}
|
|
public static string ParseStr(this FieldType value)
|
{
|
switch (value)
|
{
|
case FieldType.ELEV: return Keywords.t_ELEV;
|
case FieldType.DEMAND: return Keywords.t_DEMAND;
|
case FieldType.HEAD: return Keywords.t_HEAD;
|
case FieldType.PRESSURE: return Keywords.t_PRESSURE;
|
case FieldType.QUALITY: return Keywords.t_QUALITY;
|
case FieldType.LENGTH: return Keywords.t_LENGTH;
|
case FieldType.DIAM: return Keywords.t_DIAM;
|
case FieldType.FLOW: return Keywords.t_FLOW;
|
case FieldType.VELOCITY: return Keywords.t_VELOCITY;
|
case FieldType.HEADLOSS: return Keywords.t_HEADLOSS;
|
case FieldType.LINKQUAL: return Keywords.t_LINKQUAL;
|
case FieldType.STATUS: return Keywords.t_STATUS;
|
case FieldType.SETTING: return Keywords.t_SETTING;
|
case FieldType.REACTRATE: return Keywords.t_REACTRATE;
|
case FieldType.FRICTION: return Keywords.t_FRICTION;
|
default: return null;
|
}
|
}
|
|
public static bool TryParse(this string text, out FlowUnitsType result)
|
{
|
if (text.Match(Keywords.w_CFS)) result = FlowUnitsType.Cfs;
|
else if (text.Match(Keywords.w_GPM)) result = FlowUnitsType.Gpm;
|
else if (text.Match(Keywords.w_MGD)) result = FlowUnitsType.Mgd;
|
else if (text.Match(Keywords.w_IMGD)) result = FlowUnitsType.Imgd;
|
else if (text.Match(Keywords.w_AFD)) result = FlowUnitsType.Afd;
|
else if (text.Match(Keywords.w_LPS)) result = FlowUnitsType.Lps;
|
else if (text.Match(Keywords.w_LPM)) result = FlowUnitsType.Lpm;
|
else if (text.Match(Keywords.w_MLD)) result = FlowUnitsType.Mld;
|
else if (text.Match(Keywords.w_CMH)) result = FlowUnitsType.Cmh;
|
else if (text.Match(Keywords.w_CMD)) result = FlowUnitsType.Cmd;
|
else
|
{
|
result = (FlowUnitsType)(-1);
|
return false;
|
}
|
|
return true;
|
}
|
|
public static string ParseStr(this FlowUnitsType value)
|
{
|
switch (value)
|
{
|
case FlowUnitsType.Afd: return Keywords.w_AFD;
|
case FlowUnitsType.Cfs: return Keywords.w_CFS;
|
case FlowUnitsType.Cmd: return Keywords.w_CMD;
|
case FlowUnitsType.Cmh: return Keywords.w_CMH;
|
case FlowUnitsType.Gpm: return Keywords.w_GPM;
|
case FlowUnitsType.Imgd: return Keywords.w_IMGD;
|
case FlowUnitsType.Lpm: return Keywords.w_LPM;
|
case FlowUnitsType.Lps: return Keywords.w_LPS;
|
case FlowUnitsType.Mgd: return Keywords.w_MGD;
|
case FlowUnitsType.Mld: return Keywords.w_MLD;
|
default: return null;
|
}
|
}
|
|
/// <summary>Parse string id.</summary>
|
public static string ParseStr(this HeadLossFormulaType value)
|
{
|
switch (value)
|
{
|
case HeadLossFormulaType.CM: return Keywords.w_CM;
|
case HeadLossFormulaType.DW: return Keywords.w_DW;
|
case HeadLossFormulaType.HW: return Keywords.w_HW;
|
default: return null;
|
}
|
}
|
|
public static bool TryParse(this string text, out QualType result)
|
{
|
if (text.Match(Keywords.w_NONE)) result = QualType.None;
|
else if (text.Match(Keywords.w_CHEM)) result = QualType.Chem;
|
else if (text.Match(Keywords.w_AGE)) result = QualType.Age;
|
else if (text.Match(Keywords.w_TRACE)) result = QualType.Trace;
|
else
|
{
|
result = (QualType)(-1);
|
return false;
|
}
|
|
return true;
|
}
|
|
public static bool TryParse(this string text, out StatusLevel result)
|
{
|
if (text.Match(Keywords.w_NO)) result = StatusLevel.None;
|
else if (text.Match(Keywords.w_FULL)) result = StatusLevel.FULL;
|
else if (text.Match(Keywords.w_YES)) result = StatusLevel.Normal;
|
else
|
{
|
result = (StatusLevel)(-1);
|
return false;
|
}
|
|
return true;
|
}
|
|
public static string ParseStr(this StatusLevel value)
|
{
|
switch (value)
|
{
|
case StatusLevel.None: return Keywords.w_NO;
|
case StatusLevel.FULL: return Keywords.w_FULL;
|
case StatusLevel.Normal: return Keywords.w_YES;
|
default: return null;
|
}
|
}
|
|
public static string ParseStr(this TstatType value)
|
{
|
switch (value)
|
{
|
case TstatType.Average: return Keywords.w_AVG;
|
case TstatType.Maximum: return Keywords.w_MAX;
|
case TstatType.Minimum: return Keywords.w_MIN;
|
case TstatType.Range: return Keywords.w_RANGE;
|
case TstatType.None: return Keywords.w_NONE;
|
default: return null;
|
}
|
}
|
public static bool TryParse(this string text, out TstatType result)
|
{
|
if (text.Match(Keywords.w_NONE)) result = TstatType.None;
|
else if (text.Match(Keywords.w_NO)) result = TstatType.None;
|
else if (text.Match(Keywords.w_AVG)) result = TstatType.Average;
|
else if (text.Match(Keywords.w_MIN)) result = TstatType.Minimum;
|
else if (text.Match(Keywords.w_MAX)) result = TstatType.Maximum;
|
else if (text.Match(Keywords.w_RANGE)) result = TstatType.Range;
|
else
|
{
|
result = (TstatType)(-1);
|
return false;
|
}
|
|
return true;
|
}
|
|
public static bool TryParse(this string text, out RangeType result)
|
{
|
if (text.Match(Keywords.w_BELOW)) result = RangeType.LOW;
|
else if (text.Match(Keywords.w_ABOVE)) result = RangeType.HI;
|
else if (text.Match(Keywords.w_PRECISION)) result = RangeType.PREC;
|
else
|
{
|
result = (RangeType)(-1);
|
return false;
|
}
|
|
return true;
|
}
|
|
public static string ParseStr(this SectType value)
|
{
|
if (value < SectType.TITLE || value > SectType.END)
|
{
|
// throw new System.ArgumentOutOfRangeException("value");
|
return null;
|
}
|
|
return "[" + value + "]";
|
}
|
|
public static string ParseStr(this PressUnitsType value)
|
{
|
switch (value)
|
{
|
case PressUnitsType.KPA: return Keywords.w_KPA;
|
case PressUnitsType.METERS: return Keywords.w_METERS;
|
case PressUnitsType.PSI: return Keywords.w_PSI;
|
default: return null;
|
}
|
}
|
|
public static bool TryParse(this string text, out PressUnitsType result)
|
{
|
if (text.Match(Keywords.w_PSI)) result = PressUnitsType.PSI;
|
else if (text.Match(Keywords.w_KPA)) result = PressUnitsType.KPA;
|
else if (text.Match(Keywords.w_METERS)) result = PressUnitsType.METERS;
|
else
|
{
|
result = (PressUnitsType)(-1);
|
return false;
|
}
|
|
return true;
|
|
}
|
|
public static bool TryParse(this string text, out HeadLossFormulaType result)
|
{
|
if (text.Match(Keywords.w_HW)) result = HeadLossFormulaType.HW;
|
else if (text.Match(Keywords.w_DW)) result = HeadLossFormulaType.DW;
|
else if (text.Match(Keywords.w_CM)) result = HeadLossFormulaType.CM;
|
else
|
{
|
result = (HeadLossFormulaType)(-1);
|
return false;
|
}
|
|
return true;
|
}
|
|
public static bool TryParse(this string text, out HydType result)
|
{
|
if (text.Match(Keywords.w_USE)) result = HydType.USE;
|
else if (text.Match(Keywords.w_SAVE)) result = HydType.SAVE;
|
else
|
{
|
result = (HydType)(-1);
|
return false;
|
}
|
|
return true;
|
}
|
|
public static bool TryParse(this string text, out ValveType result)
|
{
|
if (text.Match(Keywords.w_PRV)) result = ValveType.PRV;
|
else if (text.Match(Keywords.w_PSV)) result = ValveType.PSV;
|
else if (text.Match(Keywords.w_FCV)) result = ValveType.FCV;
|
else if (text.Match(Keywords.w_TCV)) result = ValveType.TCV;
|
else if (text.Match(Keywords.w_PBV)) result = ValveType.PBV;
|
else if (text.Match(Keywords.w_GPV)) result = ValveType.GPV;
|
else
|
{
|
result = (ValveType)(-1);
|
return false;
|
}
|
|
return true;
|
}
|
}
|
|
}
|
