/// <summary>
///
/// </summary>
/// <param name="task"></param>
/// <param name="parseResult"></param>
public override void OnProcess(ITask task, IParseResult pr)
{
if (pr.IsSuccess)
{
string opera = task.Opera.Name;
if (StringHelper.Equal(opera, LYR001OperaNames.ReadReal))
{
ProcessReadReal(task, pr);
}
else if (StringHelper.Equal(opera, LYR001OperaNames.ReadStatus))
{
ProcessReadStatus(task, pr);
}
else if (
(StringHelper.Equal(opera, LYR001OperaNames.WriteOT)) ||
(StringHelper.Equal(opera, LYR001OperaNames.WriteOTMode)) ||
(StringHelper.Equal(opera, LYR001OperaNames.OPERA_READ)) ||
(StringHelper.Equal(opera, LYR001OperaNames.OPERA_WRITE)) ||
(StringHelper.Equal(opera, "ReadM"))
)
{
//task.Opera.next
}
else
{
string s = string.Format("not process LYR001 opera '{0}'", opera);
throw new NotImplementedException(s);
}
}
}
public void ObjectValidator()
{
CliParser fp = new CliParserBuilder()
.AddVerb <OptOneOfEach>("verb", verb =>
{
verb.AddOption(x => x.Option, x => x.WithShortAndLongName("o", "opt"));
verb.ValidateObject = (obj) => obj.Option < 50 ? null : "Too much!";
})
.Build();
IParseResult pr = fp.Parse(new string[] { "verb", "-o", "10" });
Assert.IsType <SuccessfulParse <OptOneOfEach> >(pr);
Assert.True(pr.Ok);
Assert.Empty(pr.Errors);
pr = fp.Parse(new string[] { "verb", "--opt", "999" });
Assert.IsType <FailedParseWithVerb <OptOneOfEach> >(pr);
Assert.False(pr.Ok);
Assert.Equal(1, pr.Errors.Count);
var error = pr.Errors.First();
Assert.Equal(ErrorCode.ObjectFailedValidation, error.ErrorCode);
Assert.Equal("Too much!", error.Message);
}
/// <summary>
///
/// </summary>
/// <param name="xgdevice"></param>
/// <param name="parseResult"></param>
private void ProcessXGDeviceRecordHelp(XGDevice xgdevice, IParseResult parseResult, bool isFD)
{
// 1. uploadrecord
// 2. readrecord
// 2.1 return record
// 2.2 return record count if record idx out of range
/*
* if (parseResult.IsSuccess)
* {
* if (StringHelper.Equal(parseResult.ReceivePartName, "recordcount"))
* {
* string errmsg = string.Format("record index '{0}' out of range",
* parseResult.NameObjects.GetObject("recordcount"));
* //CZGRApp.Default.MainForm.UpdateXGDeviceState(xgdevice, errmsg);
* log.Warning(errmsg);
*
* }
* else
* {
* // upload record or readrecord
* //
* DBXGDevice dbxgdevice = xgdevice.DBXGDevice;
* DateTime dt = Convert.ToDateTime(parseResult.NameObjects.GetObject("DT"));
* string cardsn = parseResult.NameObjects.GetObject("cardsn").ToString();
* DBXGData dbxgdata = new DBXGData(dbxgdevice, DBCard.FindCard(cardsn), dt);
* dbxgdata.Create();
*
* // update xgdatalistview
* //
* CZGRApp.Default.MainForm.UpdateXGData(xgdevice, parseResult, dbxgdata, isFD);
* }
* }
*/
}
private IParseResult <string> letterDigit(ref Cursor cursor)
{
IParseResult <string> r0 = null;
r0 = this.ParseClass(ref cursor, "AZaz09");
return(r0);
}
private static IParseResult ParseRtf(ParserState state)
{
if (state.Current != '{')
{
return(FailedParse.Get);
}
state.Advance();
IParseResult result = ParseHeader(state);
if (result.Failed)
{
return(result);
}
result = ParseDocument(state);
if (result.Failed)
{
return(result);
}
if (state.Current != '}')
{
return(FailedParse.Get);
}
state.Advance();
return(result);
}
public void FailureGivesNothing()
{
IParseResult r = parser.Parse("Nothing");
Assert.False(r.Ok);
Assert.Null(r.Verb);
}
private void SuggestBox_SelectedIndexChanged(object sender, EventArgs e)
{
var result = sug.SuggestBox.SelectedItem as IParseResult;
CurResult = result;
SetCmdInfo();
}
public void TraceRuleExit <T>(string ruleName, Cursor cursor, IParseResult <T> parseResult)
{
var success = parseResult != null;
Trace.Unindent();
Trace.WriteLine($"End '{ruleName}' with {(success ? "success" : "failure")} at ({cursor.Line},{cursor.Column}) with state key {cursor.StateKey}");
}
public void TraceRuleExit <T>(string ruleName, Cursor cursor, IParseResult <T> parseResult)
{
var success = parseResult != null;
_indentLevel--;
_builder.AppendLine(new string(' ', _indentLevel)).Append($"End '{ruleName}' with {(success ? "success" : "failure")} at ({cursor.Line},{cursor.Column}) with state key {cursor.StateKey}");
}
private void ltbSuggests_SelectedIndexChanged(object sender, EventArgs e)
{
var result = ltbSuggests.SelectedItem as IParseResult;
CurResult = result;
SetCmdInfo();
}
public override void OnProcess(ITask task, IParseResult pr)
{
if (pr.IsSuccess)
{
if (StringHelper.Equal(task.Opera.Name, "ReadReal"))
{
Xd202Data data = new Xd202Data();
data.BeforeWL = Convert.ToDouble(task.LastParseResult.Results["BeforeWL"]);
data.BehindWL = Convert.ToDouble(task.LastParseResult.Results["BehindWL"]);
data.Height = Convert.ToDouble(task.LastParseResult.Results["Height"]);
data.InstantFlux = Convert.ToDouble(task.LastParseResult.Results["IF"]);
data.RemainedAmount = Convert.ToDouble(task.LastParseResult.Results["RemainedAmount"]);
data.UsedAmount = 0 - data.RemainedAmount;
data.BeforeWL = CM2M(data.BeforeWL);
data.BehindWL = CM2M(data.BehindWL);
data.Height = CM2M(data.Height);
task.Device.DeviceDataManager.Last = data;
int id = GuidHelper.ConvertToInt32(task.Device.Guid);
DBI.Instance.InsertXd202Data(id, data);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="device"></param>
/// <param name="received"></param>
/// <returns></returns>
public override IParseResult OnParseReceivedBytes(IDevice device, byte[] received)
{
IParseResult pr = this.ReceiveParts.ToValues(received);
if (pr.IsSuccess)
{
// has address data field
//
KeyValue addressKV = pr.Results.Find(ADDRESS);
bool hasAddress = addressKV != null;
if (hasAddress)
{
// match address
//
object addressObject = pr.Results[ADDRESS];
if (addressObject != null)
{
UInt64 address = Convert.ToUInt64(addressObject);
if (address != device.Address)
{
pr = new AddressErrorResult(device.Address, address);
}
}
}
}
return(pr);
}
public void TraceResult <TResult>(IParseResult <TResult> result)
{
Contract.Requires(result != null);
if (stopwatch != null)
{
int endIndex = cursor.CurrentIndex + result.Length - 1;
string end =
endIndex > cursor.CurrentIndex
? "-" + endIndex
: endIndex < cursor.CurrentIndex
? " (Non-Greedy)"
: string.Empty;
ParserTraceSources.Execution.TraceEvent(
TraceEventType.Verbose,
0,
"Parser {0}{1} iteration {2} in {3} at index {4}{5} = {6}",
id,
name,
iteration,
stopwatch.Elapsed,
cursor.CurrentIndex,
end,
result.Value);
}
}
/// <summary>
///
/// </summary>
/// <param name="task"></param>
/// <param name="pr"></param>
internal AdjusterControlInfoReader(ITask task, IParseResult pr)
{
Debug.Assert(pr.IsSuccess);
_task = task;
_pr = pr;
}
public IParseResultGroup Parse(ILexResultGroup lexedSource)
{
// initialize group
IParseResultGroup parseGroup = new ParseResultGroup(
ParseStatus.Success,
new ASTNode(ParseMatchType.Program, lexedSource)
);
Action <IParseResult> addItem = pr => {
if (pr.Status != ParseStatus.None)
{
parseGroup.Node.Add(pr.Node);
parseGroup.Add(pr);
}
};
foreach (IParseRule rule in _parserRules)
{
foreach (ILexResult lexResult in lexedSource)
{
if (!rule.Accepts(lexResult))
{
continue;
}
IParseResult parseResult = rule.Parse(lexResult);
addItem(parseResult);
}
}
return(parseGroup);
}
public void TraceRuleExit <T>(string ruleName, Cursor cursor, IParseResult <T> parseResult)
{
if (Enabled)
{
Out.WriteLine($"Exit rule: {ruleName} result: {parseResult}");
}
}
/// <summary>
/// Handles <paramref name="result"/>. If parsing was successful, calls <see cref="IParseResult.InvokeAsync"/>.
/// If parsing failed, any errors are written using <see cref="MsgFormatter"/>.
/// </summary>
/// <param name="result">The result to handle.</param>
/// <param name="alwaysWriteHelpOnError">Always writes help when there is an error. If false, only writes help if an Error was <see cref="ErrorCode.HelpRequested"/>.</param>
public async Task HandleAsync(IParseResult result, bool alwaysWriteHelpOnError = true)
{
if (result.Ok)
{
await result.InvokeAsync();
}
else
{
if (result.Errors.Count > 0)
{
MsgFormatter.WriteErrors(Console, result.Errors);
}
if (alwaysWriteHelpOnError || result.Errors.Any(x => x.ErrorCode == ErrorCode.HelpRequested))
{
if (result.Verb != null)
{
result.Verb.WriteSpecificHelp(Console, MsgFormatter);
}
else
{
MsgFormatter.WriteOverallHelp(Console, Verbs, Config);
}
}
}
}
private static IParseResult ParseDocument(ParserState state)
{
StringBuilder sb = new StringBuilder();
while (state.Current != '}')
{
if (state.Current == '\\')
{
IParseResult result = ParseDocEscapedChar(state);
if (result.Succeeded)
{
sb.Append(ConvertEntity(state.Current));
state.Advance();
}
else
{
result = ParseKeyword(state);
if (result.Failed)
{
return(result);
}
string s = ProcessDocKeyword(result.Value, state);
sb.Append(s);
}
}
else
{
sb.Append(ConvertEntity(state.Current));
state.Advance();
}
}
return(new SuccessfulParse(sb.ToString()));
}
private void WriteLoadFile(string file, TableMetadata tableMetadata, IParseResult items)
{
StringBuilder builder = new StringBuilder();
var columns = tableMetadata.Columns;
var isAutoIncrementPrimary = tableMetadata.IsAutoIncrementPrimary;
var insertColumns =
(isAutoIncrementPrimary ? columns.Where(c1 => c1.Key != tableMetadata.Primary.First()) : columns)
.ToArray();
foreach (var item in items)
{
builder.Append("@END@");
foreach (var column in insertColumns)
{
var value = column.Value.PropertyInfo.GetValue(item);
value = value == null ? "" : MySqlHelper.EscapeString(value.ToString());
builder.Append("#").Append(value).Append("#").Append("$");
}
}
StreamWriter writer = CreateOrOpen(file);
lock (writer)
{
writer.WriteLine(builder.ToString());
}
builder.Clear();
}
private static IParseResult ParseHeaderGroup(ParserState state)
{
if (state.Current != '{')
{
return(FailedParse.Get);
}
state.Advance();
IParseResult result = ParseHeaderKeyword(state);
if (result.Failed)
{
return(result);
}
if (result.Value == "colortbl")
{
result = ParseColors(state);
}
else
{
result = ParseHeaderGroupData(state);
}
if (state.Current != '}')
{
return(FailedParse.Get);
}
state.Advance();
return(result);
}
/// <summary>
///
/// </summary>
/// <param name="device"></param>
/// <param name="bs"></param>
/// <returns></returns>
public PickResult Pick(IDevice device, byte[] bs)
{
int length = 0;
if (bs != null)
{
length = bs.Length;
}
if (length < _receivePard.DataFieldManager.Length)
{
return(PickResult.CreateFailPickResult(bs));
}
for (int i = 0; i <= bs.Length - _receivePard.DataFieldManager.Length; i++)
{
byte[] bsForParse = new byte[_receivePard.DataFieldManager.Length];
Array.Copy(bs, i, bsForParse, 0, _receivePard.DataFieldManager.Length);
IParseResult pr = _receivePard.ToValues(bsForParse);
if (pr.IsSuccess)
{
byte[] remain = Remove(bs, i, _receivePard.DataFieldManager.Length);
PickResult success = PickResult.CreateSuccessPickResult(
this.Name, pr, remain);
return(success);
}
}
return(PickResult.CreateFailPickResult(bs));
}
public override void OnProcess(ITask task, IParseResult pr)
{
string s = string.Format("{0} - {1} - {2}",
DateTime.Now, task.Opera.Name, pr);
Console.WriteLine(s);
}
/// <summary>
/// Succeeds with a successful parser, if any.
/// </summary>
/// <remarks>The first successful parser that advances the text position is returned.
/// Otherwise, the first successful parser that does not advance the text position is returned.
/// Otherwise, the first failure is returned.</remarks>
public static IParser <T> Or <T>(IEnumerable <IParser <T> > parsers)
{
return(Create(position =>
{
IParseResult <T> firstEmptySuccess = null;
IParseResult <T> firstFailure = null;
foreach (IParser <T> parser in parsers)
{
IParseResult <T> result = parser.TryParse(position);
if (!result.Success)
{
firstFailure = firstFailure ?? result;
}
else if (result.NextPosition == position)
{
firstEmptySuccess = firstEmptySuccess ?? result;
}
else
{
return result;
}
}
return firstEmptySuccess ?? firstFailure ?? ParseResult.Failure <T>(position);
}));
}
/// <summary>
///
/// </summary>
/// <param name="st"></param>
/// <param name="parseResult"></param>
private void ProcessXGReadRecordResult(XGDevice xgdevice, IParseResult pr)
{
DateTime dt = (DateTime)pr.Results["DT"];
string cardSn = pr.Results["cardsn"].ToString();
dt = SaveToDBAndUpdateLast(xgdevice, dt, cardSn);
}
private IParseResult <OutputNode> statement(ref Cursor cursor)
{
IParseResult <OutputNode> r0 = null;
r0 = this.output(ref cursor);
return(r0);
}
private IParseResult <string> @operator(ref Cursor cursor)
{
IParseResult <string> r0 = null;
if (r0 == null)
{
r0 = this.ParseLiteral(ref cursor, ">=");
}
if (r0 == null)
{
r0 = this.ParseLiteral(ref cursor, "<=");
}
if (r0 == null)
{
r0 = this.ParseLiteral(ref cursor, ">");
}
if (r0 == null)
{
r0 = this.ParseLiteral(ref cursor, "<");
}
if (r0 == null)
{
r0 = this.ParseLiteral(ref cursor, "==");
}
if (r0 == null)
{
r0 = this.ParseLiteral(ref cursor, "!=");
}
if (r0 == null)
{
r0 = this.ParseLiteral(ref cursor, "~=");
}
return(r0);
}
private IParseResult <IList <string> > _(ref Cursor cursor)
{
IParseResult <IList <string> > r0 = null;
var startCursor0 = cursor;
var l0 = new List <string>();
while (true)
{
IParseResult <string> r1 = null;
r1 = this.ParseClass(ref cursor, "\t\t ");
if (r1 != null)
{
l0.Add(r1.Value);
}
else
{
break;
}
}
if (l0.Count >= 1)
{
r0 = this.ReturnHelper <IList <string> >(startCursor0, ref cursor, state => l0.AsReadOnly());
}
else
{
cursor = startCursor0;
}
return(r0);
}
/// <summary>
///
/// </summary>
/// <param name="task"></param>
/// <param name="pr"></param>
public override void OnProcess(ITask task, IParseResult pr)
{
if (pr.IsSuccess)
{
string opera = task.Opera.Name;
if (StringHelper.Equal(opera, XD1100OperaNames.ReadReal))
{
ProcessReadReal(task, pr);
}
else if( StringHelper.Equal ( opera, XD1100OperaNames.ReadStatus ))
{
ProcessReadStatus(task, pr);
}
else if (
(StringHelper.Equal(opera, XD1100OperaNames.WriteOT)) ||
(StringHelper.Equal(opera, XD1100OperaNames.WriteOTMode)) ||
(StringHelper.Equal(opera, XD1100OperaNames.OPERA_READ)) ||
(StringHelper.Equal(opera, XD1100OperaNames.OPERA_WRITE))
)
{
}
else
{
string s = string.Format("not process xd1100 opera '{0}'", opera);
throw new NotImplementedException(s);
}
}
}
/// <inheritdoc/>
public override IParseResult <T> TryParse(string input, int position)
{
IParseResult <T> firstResult = First.TryParse(input, position);
if (firstResult.Success)
{
return(firstResult);
}
IParseResult <T> secondResult = Second.TryParse(input, position);
if (secondResult.Success)
{
return(secondResult);
}
IEnumerable <string> newExpected = Array.Empty <string>();
if (firstResult.Error is UnexpectedTokenError t1)
{
newExpected = newExpected.Concat(t1.Expected);
}
if (secondResult.Error is UnexpectedTokenError t2)
{
newExpected = newExpected.Concat(t2.Expected);
}
return(new ParseResult <T>(position, secondResult.Position, new UnexpectedTokenError(newExpected, GetFound(input, position))));
}
public static void ShouldSucceed <T>(this IParseResult <T> actual, T expected, int?remainderIndex = null)
{
Assert.True(actual.Success, "parse failed");
if (expected is IEnumerable sequence && !(expected is string))
{
Assert.True(sequence.Cast <object>().SequenceEqual(((IEnumerable)actual.Value !).Cast <object>()));
}
/// <summary>
///
/// </summary>
/// <param name="client"></param>
/// <param name="received"></param>
/// <returns></returns>
public bool Process(Client client, byte[] received)
{
StringBuilder sb = new StringBuilder();
IParseResult pr = this.GetReceivePart().ToValues(received);
if (pr.IsSuccess)
{
string name = Convert.ToString(pr.Results["name"]);
name = name.Trim();
DateTime dt = (DateTime)pr.Results["dt"];
sb.AppendLine(string.Format(
Strings.GateDataRequest,
name, dt));
byte[] bsReply = CreateGateReplyBytes(name, dt, sb);
bool r = client.CommuniPort.Write(bsReply);
LogItem log = new LogItem(DateTime.Now, sb.ToString());
client.LogItems.Add(log);
}
return(pr.IsSuccess);
}
/// <summary>
///
/// </summary>
/// <param name="task"></param>
/// <param name="pr"></param>
public override void OnProcess(ITask task, IParseResult pr)
{
if (pr.IsSuccess)
{
string opera = task.Opera.Name;
opera = opera.ToLower();
XGDevice xgdevice = (XGDevice)task.Device;
switch (opera)
{
case XGOperaNames.ReadCount:
ProcessXGReadRecordCountResult(xgdevice, pr);
break;
case XGOperaNames.ReadRecord:
ProcessXGReadRecordResult(xgdevice, pr);
break;
case XGOperaNames.RecordUpload:
ProcessXGUploadRecordResult(xgdevice, pr);
break;
case XGOperaNames.ClearRecord:
ProcessXGClearRecordResult(pr);
break;
case XGOperaNames.RemoveUpload:
ProcessXGRemoveUploadResult(pr);
break;
case XGOperaNames.ReadXGDate:
ProcessXGReadDateResult(xgdevice, pr);
break;
case XGOperaNames.ReadXGTime:
ProcessXGReadTimeResult(xgdevice, pr);
break;
case XGOperaNames.WriteXGDate:
case XGOperaNames.WriteXGTime:
case XGOperaNames.WriteMode:
// do nothing
//
break;
default:
{
string errmsg = string.Format("{0} {1}",
xgdevice.DeviceType.Text,
opera);
throw new NotSupportedException(errmsg);
}
}
}
}
/// <summary>
///
/// </summary>
/// <param name="device"></param>
/// <param name="bs"></param>
/// <returns></returns>
//public override IUploadParseResult OnProcessUpload(IDevice device, byte[] bs)
public override void OnProcessUpload(IDevice device, IParseResult pr)
{
XGDevice xg = (XGDevice)device;
DateTime dt = (DateTime)pr.Results["DT"];
string cardSN = pr.Results["cardSN"].ToString();
//xg.DeviceDataManager.Last = new XGData(dt, cardSN);
SaveToDBAndUpdateLast(xg, dt, cardSN);
IOpera op = device.Dpu.OperaFactory.Create(device.GetType().Name,
XGOperaNames.RemoveUpload);
TimeSpan timeout = TimeSpan.FromMilliseconds(device.Station.CommuniPortConfig.TimeoutMilliSecond);
Task task = new Task(device, op, Strategy.CreateImmediateStrategy(), timeout,1);
device.TaskManager.Tasks.Enqueue(task);
}
private static List<DmxPatchGroup> ParseDmxPatchgroup(XElement source, IParseResult result)
{
var patchGroups = source.Elements("DmxPatchgroup");
List<DmxPatchGroup> groups = new List<DmxPatchGroup>();
if (patchGroups.Any())
{
foreach (XElement dmxpgroupElement in patchGroups)
{
var dmxpgroup = new DmxPatchGroup();
ParseResult error = new ParseResult(dmxpgroupElement.Name.LocalName);
string val;
TryExecute(
() =>
{
val = ParseAttribute<string>(dmxpgroupElement, "PatchFootprint");
Validate(() => Validator.HasValue(val));
dmxpgroup.PatchFootprint = ParseValue<int>(val);
}, "PatchFootprint", error);
TryExecute(
() =>
{
val = ParseAttribute<string>(dmxpgroupElement, "PatchGroupLabel");
dmxpgroup.PatchGroupLabel = val;
}, "PatchGroupLabel", error);
TryExecute(
() =>
{
dmxpgroup.Channels = ParseDmxChannel(dmxpgroupElement, error);
}, "DmxChannel", error);
TryExecute(
() =>
{
var node = dmxpgroupElement.GetElement("DmxMacros", false);
if (node != null)
dmxpgroup.Macros = ParseDmxMacro(node, error);
}, "DmxMacros", error);
if(error.FieldsWithError.Count == 0)
groups.Add(dmxpgroup);
if (error.HaveError) result.ErrorList.Add(error);
}
}
return groups;
}
/// <summary>
///
/// </summary>
/// <param name="device"></param>
/// <param name="pr"></param>
public void ProcessUpload(IDevice device, IParseResult pr)
{
OnProcessUpload(device, pr);
}
private static List<DmxChannel> ParseDmxChannel(XElement source, IParseResult result)
{
List<DmxChannel> channels = new List<DmxChannel>();
var channelElements = source.Elements("DmxChannel");
if (channelElements.Any())
{
foreach (XElement dmxChannelElement in channelElements)
{
var dmxChannel = new DmxChannel();
ParseResult error = new ParseResult(dmxChannelElement.Name.LocalName);
string val;
TryExecute(
() =>
{
val = ParseAttribute<string>(dmxChannelElement, "ChannelNum");
Validate(() => Validator.HasValue(val));
if (HaveRangeValue(val))
{
dmxChannel.ChanelNumRange = ParseRangeValue(val);
}
else
{
dmxChannel.ChannelNum = ParseDelimited(val, ",");
if (dmxChannel.ChannelNum.Length == 0)
dmxChannel.ChannelNum = new[] { ParseValue<int>(val) };
}
}, "ChannelNum", error);
TryExecute(
() =>
{
val = ParseAttribute<string>(dmxChannelElement, "DominantFeatureGroup");
if (!string.IsNullOrWhiteSpace(val))
dmxChannel.DominantFeatureGroup = ParseEnum<FeatureGroup>(val);
}, "DominantFeatureGroup", error);
TryExecute(
() =>
{
val = ParseAttribute<string>(dmxChannelElement, "ElementNumber");
if (!string.IsNullOrWhiteSpace(val))
dmxChannel.ElementNumber = ParseValue<int>(val);
}, "ElementNumber", error);
TryExecute(
() =>
{
val = ParseElement<string>(dmxChannelElement, "Default");
if (!string.IsNullOrWhiteSpace(val))
dmxChannel.Default = ParseValue<int>(val);
}, "Default", error);
TryExecute(
() =>
{
val = ParseElement<string>(dmxChannelElement, "DmxChannelLabel");
dmxChannel.DmxChannelLabel = val;
}, "DmxChannelLabel", error);
TryExecute(
() =>
{
dmxChannel.Ranges = ParseDmxRange(dmxChannelElement, null, error);
}, "DmxRange", error);
TryExecute(
() =>
{
dmxChannel.Modules = ParseDmxModule(dmxChannelElement, error);
}, "DmxModule", error);
var conditionalRangeSets = ParseConditionalDmxRangeSet(dmxChannelElement, error);
if (conditionalRangeSets.Any())
dmxChannel.Ranges.AddRange(conditionalRangeSets.SelectMany(rs => rs.Value));
if (error.FieldsWithError.Count == 0)
channels.Add(dmxChannel);
if (error.HaveError) result.ErrorList.Add(error);
}
}
return channels;
}
/// <summary>
///
/// </summary>
/// <param name="task"></param>
/// <param name="pr"></param>
public override void OnProcess(ITask task, IParseResult pr)
{
if (pr.IsSuccess)
{
string opera = task.Opera.Name;
if (StringHelper.Equal(opera, "read"))
{
CrlgxlData data = new CrlgxlData();
data.InstantFlux = Convert.ToDouble(pr.Results["if"]);
data.Sum = Convert.ToDouble(pr.Results["sum"]);
data.InstantHeat = Convert.ToDouble(pr.Results["ih"]);
data.SumHeat = Convert.ToDouble(pr.Results["sh"]);
data.GT = Convert.ToDouble(pr.Results["gt"]);
data.BT = Convert.ToDouble(pr.Results["bt"]);
task.Device.DeviceDataManager.Last = data;
int id = GuidHelper.ConvertToInt32(task.Device.Guid);
DBI.Instance.InsertCrlgxlData(id, data);
}
}
}
private static List<DmxMacro> ParseDmxMacro(XElement source, IParseResult result)
{
List<DmxMacro> macros = new List<DmxMacro>();
var mocroElements = source.Elements("DmxMacro");
if (mocroElements.Any())
{
foreach (XElement macroElement in mocroElements)
{
var macro = new DmxMacro();
ParseResult error = new ParseResult(macroElement.Name.LocalName);
TryExecute(
() =>
{
macro.FeatureRanges = ParseFeatureRange(macroElement, error);
}, "FeatureRange", error);
TryExecute(
() =>
{
macro.TimingSets = ParseDmxTimingSet(macroElement, error);
}, "DmxTimingSet", error);
if (error.FieldsWithError.Count == 0)
macros.Add(macro);
if (error.HaveError) result.ErrorList.Add(error);
}
}
return macros;
}
private static List<DmxModule> ParseDmxModule(XElement source, IParseResult result)
{
List<DmxModule> dmxRanges = new List<DmxModule>();
var moduleElements = source.Elements("DmxModule");
if (moduleElements.Any())
{
foreach (var moduleElement in moduleElements)
{
var module = new DmxModule();
ParseResult error = new ParseResult(moduleElement.Name.LocalName);
string val;
TryExecute(
() =>
{
val = ParseAttribute<string>(moduleElement, "DmxModuleName");
Validate(() => Validator.HasValue(val));
module.Name = val;
}, "DmxModuleName", error);
TryExecute(
() =>
{
val = ParseAttribute<string>(moduleElement, "ModuleInstance");
Validate(() => Validator.HasValue(val));
module.Instance = ParseValue<int>(val);
}, "ModuleInstance", error);
if (moduleElement.HaveAttribute("TempElementModuleInstance"))
{
TryExecute(
() =>
{
val = ParseAttribute<string>(moduleElement, "TempElementModuleInstance");
Validate(() => Validator.HasValue(val));
module.TempElementModuleInstance = ParseValue<int>(val);
}, "TempElementModuleInstance", error);
}
if (error.FieldsWithError.Count == 0)
dmxRanges.Add(module);
if (error.HaveError) result.ErrorList.Add(error);
}
}
return dmxRanges;
}
private static List<DmxModuleDefinition> ParseDmxModuleDefinition(XElement source, IParseResult result)
{
List<DmxModuleDefinition> moduleDefinitions = new List<DmxModuleDefinition>();
var moduleElements = source.Elements("DmxModuleDefinition");
if (moduleElements.Any())
{
ParseResult error;
string val;
foreach (XElement moduleElement in moduleElements)
{
error = new ParseResult(moduleElement.Name.LocalName);
var module = new DmxModuleDefinition();
TryExecute(
() =>
{
val = ParseAttribute<string>(moduleElement, "DmxModuleName");
Validate(() => Validator.HasValue(val));
module.ModuleName = val;
}, "DmxModuleName", error);
TryExecute(
() =>
{
val = ParseAttribute<string>(moduleElement, "DmxModuleFootprint");
Validate(() => Validator.HasValue(val));
module.ModuleFootprint = ParseValue<int>(val);
}, "DmxModuleFootprint", error);
TryExecute(
() =>
{
module.Channels = ParseDmxChannel(moduleElement, error);
}, "DmxChannel", error);
if (error.FieldsWithError.Count == 0)
moduleDefinitions.Add(module);
if (error.HaveError) result.ErrorList.Add(error);
}
}
return moduleDefinitions;
}
public void ReportParseErrors(IParseResult parseResult, ITextSnapshot snapshot)
{
_errorListProvider.SuspendRefresh();
try
{
// remove any previously created errors to get a clean start
ClearErrors();
var messages = (CompilerMessageList)parseResult.CompilerMessages;
foreach (var error in messages.GetMessages())
{
// creates the instance that will be added to the Error List
var nSpan = error.Location.Span;
var span = new Span(nSpan.StartPos, nSpan.Length);
if (span.Start >= snapshot.Length)
continue;
ErrorTask task = new ErrorTask();
task.Category = TaskCategory.All;
task.Priority = TaskPriority.Normal;
task.Document = _textBuffer.Properties.GetProperty<ITextDocument>(typeof(ITextDocument)).FilePath;
task.ErrorCategory = TranslateErrorCategory(error);
task.Text = error.Text;
task.Line = snapshot.GetLineNumberFromPosition(span.Start);
task.Column = span.Start - snapshot.GetLineFromLineNumber(task.Line).Start;
task.Navigate += OnTaskNavigate;
_errorListProvider.Tasks.Add(task);
_previousErrors.Add(task);
var trackingSpan = snapshot.CreateTrackingSpan(span, SpanTrackingMode.EdgeNegative);
_squiggleTagger.CreateTagSpan(trackingSpan, new ErrorTag("syntax error", error.Text));
_previousSquiggles.Add(new TrackingTagSpan<IErrorTag>(trackingSpan, new ErrorTag("syntax error", error.Text)));
}
}
finally { _errorListProvider.ResumeRefresh(); }
}
private static Dictionary<MediaRangeInfo, List<Slot>> ParseMediaRangeInfo(XElement source, IParseResult result)
{
Dictionary<MediaRangeInfo,List<Slot>> ranges = new Dictionary<MediaRangeInfo, List<Slot>>();
var rangeElements = source.Elements("MediaRange");
if (rangeElements.Any())
{
MediaRangeInfo range;
ParseResult error;
string val;
XElement node;
foreach (var rangeElement in rangeElements)
{
range = new MediaRangeInfo();
error = new ParseResult(rangeElement.Name.LocalName);
TryExecute(
() =>
{
val = ParseAttribute<string>(rangeElement, "MediaType");
Validate(() => Validator.HasValue(val));
range.MediaType = ParseEnum<MediaType>(val);
}, "MediaType", error);
TryExecute(
() =>
{
val = ParseAttribute<string>(rangeElement, "MediaManufacturer");
Validate(() => Validator.HasValue(val));
range.Manufacturer = val;
}, "MediaManufacturer", error);
TryExecute(
() =>
{
val = ParseAttribute<string>(rangeElement, "MediaRangeName");
Validate(() => Validator.HasValue(val));
range.Name = val;
}, "MediaRangeName", error);
if (error.FieldsWithError.Count == 0)
{
ranges[range] = ParseSlot(rangeElement, range, error);
}
if (error.HaveError) result.ErrorList.Add(error);
}
}
return ranges;
}
/// <summary>
///
/// </summary>
/// <param name="task"></param>
/// <param name="pr"></param>
private void ProcessReadStatus(ITask task, IParseResult pr)
{
XD1100Device d = (XD1100Device ) task.Device;
byte[] bsStatus = (byte[])pr.Results["data"];
Debug.Assert(bsStatus.Length == 4);
byte b = bsStatus[3];
bool hasPowerAlarm = (b & (byte)Math.Pow(2, 7)) > 0;
d.StatusAndAlarmDictionary[XD1100Device.StatusAndAlarmEnum.AlaramPower] = hasPowerAlarm;
}
/// <summary>
///
/// </summary>
/// <param name="d"></param>
/// <param name="pr"></param>
private void ProcessReadReal(ITask task, IParseResult pr)
{
XD1100Data data = new XD1100Data();
data.DT = DateTime.Now;
data.GT1 = Convert.ToSingle(pr.Results["GT1"]);
data.BT1 = Convert.ToSingle(pr.Results["BT1"]);
data.GT2 = Convert.ToSingle(pr.Results["GT2"]);
data.BT2 = Convert.ToSingle(pr.Results["BT2"]);
data.OT = Convert.ToSingle(pr.Results["OT"]);
data.GTBase2 = Convert.ToSingle(pr.Results["GTBase2"]);
data.GP1 = Convert.ToSingle(pr.Results["GP1"]);
data.BP1 = Convert.ToSingle(pr.Results["BP1"]);
data.WL = Convert.ToSingle(pr.Results["WL"]);
data.GP2 = Convert.ToSingle(pr.Results["GP2"]);
data.BP2 = Convert.ToSingle(pr.Results["BP2"]);
data.I1 = Convert.ToSingle(pr.Results["I1"]);
data.IR = Convert.ToSingle(pr.Results["IR"]);
data.I2 = Convert.ToSingle(pr.Results["I2"]);
data.S2 = Convert.ToInt32(pr.Results["S2"]);
data.S1 = Convert.ToInt32(pr.Results["S1"]);
data.SR = Convert.ToInt32(pr.Results["SR"]);
data.OD = Convert.ToInt32(pr.Results["OD"]);
//data.IH1 = Convert.ToDouble (pr.Results ["IH1"]);
//data.SH1 = Convert.ToDouble (pr.Results ["SH1"]);
data.IH1 = 0d;
data.SH1 = 0d;
// 2012-10-09 xd1100 pump status
//
bool[] pumpStatusArray = (bool[])pr.Results["pumpstate"];
data.CM1 = IsPumpRun(pumpStatusArray[0]);
data.CM2 = IsPumpRun(pumpStatusArray[1]);
data.CM3 = IsPumpRun(pumpStatusArray[2]);
data.RM1 = IsPumpRun(pumpStatusArray[3]);
data.RM2 = IsPumpRun(pumpStatusArray[4]);
object objWarn = pr.Results["Warn"];
IList listWarn = (IList)objWarn;
bool isContainsPowerAlaram = listWarn.Contains(POWER_ALARM);
if (!isContainsPowerAlaram)
{
if (HasPowerAlaramInStatus(task.Device as XD1100Device))
{
listWarn.Add(POWER_ALARM);
}
}
WarnWrapper ww = new WarnWrapper(listWarn);
data.Warn = ww;
XD1100Device d = (XD1100Device)task.Device;
//List<IFluxProvider> fluxProviderList = GetFluxProviderList(d);
DeviceCollection fluxDevices = d.Station.Devices.GetDevices(this.KIND_FLUX);
fluxDevices = RemoveUnkonwnPlaceDevice(fluxDevices);
bool hasFluxDevices = fluxDevices.Count > 0;
bool hasFluxData = fluxDevices.HasData(HasDataOption.All);
bool success = true;
if (hasFluxDevices)
{
if (hasFluxData)
{
Hashtable fluxResultHashTable = GetFluxDatas(fluxDevices);
foreach (object obj in fluxResultHashTable.Keys)
{
FluxPlace place = (FluxPlace)obj;
List<double> list = (List<double>)fluxResultHashTable[obj];
switch (place)
{
case FluxPlace.FirstSide:
data.I1 = Convert.ToSingle(list[0]);
data.S1 = Convert.ToInt32(list[1]);
break;
case FluxPlace.SecondSide:
data.I2 = Convert.ToSingle(list[0]);
data.S2 = Convert.ToInt32(list[1]);
break;
case FluxPlace.RecruitSide:
data.IR = Convert.ToSingle(list[0]);
data.SR = Convert.ToInt32(list[1]);
break;
default:
break;
}
}
}
else
{
success = false;
}
}
if (!success)
{
return;
}
DeviceCollection heatDevices = d.Station.Devices.GetDevices(KIND_HEAT);
//heatDevices = RemoveUnkonwnPlaceDevice(heatDevices);
heatDevices = this.Filter(heatDevices, FluxPlace.FirstSide);
bool hasHeatDevices = heatDevices.Count > 0;
bool hasHeatData = heatDevices.HasData(HasDataOption.All);
if (hasHeatDevices)
{
if (hasHeatData)
{
double instantFlux = 0d;
double sumFlux = 0d;
double ih = 0d;
double sh = 0d;
foreach (IDevice hd in heatDevices)
{
IData last = hd.DeviceDataManager.Last;
ih += Convert.ToDouble(last.GetValue("InstantHeat"));
sh += Convert.ToDouble(last.GetValue("SumHeat"));
instantFlux += Convert.ToDouble(last.GetValue("InstantFlux"));
sumFlux += Convert.ToDouble(last.GetValue("Sum"));
}
data.I1 = Convert.ToSingle(instantFlux);
data.S1 = Convert.ToInt32(sumFlux);
data.IH1 = ih;
data.SH1 = sh;
}
else
{
success = false;
}
}
if (!success)
{
return;
}
switch (d.HtmMode.ModeValue)
{
case ModeValue.Indirect:
data.CyclePumpDatas.Add(new PumpData("1#", Convert.ToInt32(pr.Results["cyclefrequency"])));
data.RecruitPumpDatas.Add(new PumpData("1#", Convert.ToInt32(pr.Results["recruitfrequency"])));
break;
case ModeValue.Direct:
data.GT1 = data.GT2;
data.BT1 = data.BT2;
break;
case ModeValue.Mixed:
data.BT1 = data.BT2;
data.CyclePumpDatas.AddRange(
new PumpData("1#", Convert.ToInt32(pr.Results["cyclefrequency"])),
new PumpData("2#", Convert.ToInt32(pr.Results["recruitfrequency"])),
new PumpData("3#", Convert.ToInt32(pr.Results["I2"])));
break;
}
d.DeviceDataManager.Last = data;
// save
//
int id = GuidHelper.ConvertToInt32(d.Guid);
DBI.Instance.InsertXD1100Data(id, data);
}
public abstract void OnProcessUpload(IDevice device, IParseResult pr);
/// <summary>
/// Creates an instance.
/// </summary>
public ParseException(IParseResult result)
: base(result.ToMessage())
{
Result = result;
}
/// <summary>
///
/// </summary>
/// <param name="device"></param>
/// <param name="pr"></param>
public override void OnProcessUpload(IDevice device, IParseResult pr)
{
//throw new NotImplementedException();
}
private static List<FeatureRange> ParseFeatureRange(XElement source, IParseResult result)
{
List<FeatureRange> ranges = new List<FeatureRange>();
var rangeElements = source.Elements("FeatureRange");
if (rangeElements.Any())
{
foreach (var rangeElement in rangeElements)
{
var range = new FeatureRange();
ParseResult error = new ParseResult(rangeElement.Name.LocalName);
string val;
XElement node;
TryExecute(
() =>
{
val = ParseAttribute<string>(rangeElement, "FeatureName");
Validate(() => Validator.HasValue(val));
range.FeatureName = ParseEnum<FeatureName>(val);
}, "FeatureName", error);
TryExecute(
() =>
{
node = rangeElement.GetElement("Value", false);
if(node == null) return;
range.Value = node.Value;
TryExecute(
() =>
{
val = ParseAttribute<string>(node, "UnitName");
Validate(() => Validator.HasValue(val));
range.UnitName = ParseEnum<UnitType>(val);
}, "UnitName", error);
}, "Value", error);
if (error.FieldsWithError.Count == 0)
ranges.Add(range);
if (error.HaveError) result.ErrorList.Add(error);
}
}
return ranges;
}
/// <summary>
///
/// </summary>
/// <param name="task"></param>
/// <param name="pr"></param>
public override void OnProcess(ITask task, IParseResult pr)
{
if (pr.IsSuccess)
{
//Xd100eData data = Xd100eData.GetCachedData();
Xd100e xd100eDevice = (Xd100e)task.Device;
Xd100eData data = xd100eDevice.GetCachedData();
Console.WriteLine("ori xd100e id: " + GuidHelper.ConvertToInt32(xd100eDevice.Guid));
string opera = task.Opera.Name;
if (StringHelper.Equal(opera, READ_REAL))
{
for (int i = Xd100eData.BeginChannelNO; i <= Xd100eData.EndChannelNO; i++)
{
int no = i;
string channelName = GetChannelName(no);
float val = Convert.ToSingle(pr.Results[channelName]);
val /= 100f;
data.SetChannelDataAI(no, val);
data.IsSetAI = true;
}
}
else if (StringHelper.Equal(opera, READ_REAL_DI))
{
//XD100EData data = xd100eDevice.XD100EData;
for (int i = Xd100eData.BeginChannelNO; i <= Xd100eData.EndChannelNO; i++)
{
int no = i;
string channelName = GetChannelName(no);
byte value = Convert.ToByte(pr.Results[channelName]);
data.SetChannelDataDI(no, value > 0);
data.IsSetDI = true;
}
}
//
//
if (data.IsComplete())
{
double ir = 0d, sr = 0d;
//bool hasRecuritFluxDevice;
string recuritEx = string.Empty;
//bool success = GetFluxValues(xd100eDevice, FluxPlace.RecruitSide, out hasRecuritFluxDevice,
// out ir, out sr, out recuritEx);
// get kind == fluxdevice device collection
//
DeviceCollection rDevices = xd100eDevice.Station.Devices.GetDevices(KIND_FLUX_DEVICE);
rDevices = Filter(rDevices, FluxPlace.RecruitSide);
bool hasRecuritFluxDevice = rDevices.Count > 0;
bool hasRecuritFluxData = rDevices.HasData(HasDataOption.All);
if (hasRecuritFluxData)
{
ir = Calc(rDevices, "InstantFlux", CalcType.Sum);
sr = Calc(rDevices, "Sum", CalcType.Sum);
recuritEx = GetRecuritEx(rDevices);
}
// get recruite device collection
// get recruite data
//
// get kind == heatdevcie device collection
// check has data
// [x] get place == first ?
// get device gt bt
double if1 = 0d, sf1 = 0d, gt1 = 0d, bt1 = 0d, ih1 = 0d, sh1=0d;
//bool hasFirstFluxDevice;
//string firstEx;
//bool success2 = GetFluxValues(xd100eDevice, FluxPlace.FirstSide, out hasFirstFluxDevice,
// out if1, out sf1, out firstEx);
DeviceCollection hs = xd100eDevice.Station.Devices.GetDevices(KIND);
hs = Filter(hs, FluxPlace.FirstSide);
bool hasFirstFluxDevice = hs.Count > 0;
bool hasFirstFluxData = hs.HasData(HasDataOption.All);
if (hasFirstFluxData)
{
if1 = Calc(hs, "InstantFlux", CalcType.Sum);
sf1 = Calc(hs, "Sum", CalcType.Sum);
gt1 = Calc(hs, "GT", CalcType.Avg);
bt1 = Calc(hs, "BT", CalcType.Avg);
ih1 = Calc(hs, "InstantHeat", CalcType.Sum);
sh1 = Calc(hs, "SumHeat", CalcType.Sum);
}
bool success = true;
if (hasRecuritFluxDevice )
{
if (hasRecuritFluxData)
{
data.IR = ir;
data.SR = sr;
data.REx = recuritEx;
}
else
{
success = false;
}
}
//
//
if (success)
{
if (hasFirstFluxDevice)
{
if (hasFirstFluxData)
{
// xd100e ai5 == if1
//
// ai1 - gt1, ai2 - bt1
//
data.IF1 = if1;
data.SF1 = sf1;
data.AI5 = Convert.ToSingle(if1);
data.AI1 = Convert.ToSingle(gt1);
data.AI2 = Convert.ToSingle(bt1);
data.IH1 = ih1;
data.SH1 = sh1;
}
else
{
success = false;
}
}
}
if (success)
{
data.DT = DateTime.Now;
xd100eDevice.DeviceDataManager.Last = data;
int deviceID = GuidHelper.ConvertToInt32(xd100eDevice.Guid);
Console.WriteLine("write xd100e id: " + deviceID);
DBI.Instance.InsertXd100eData(deviceID, data);
}
//if (success && success2)
//{
// data.IR = ir;
// data.SR = sr;
// data.REx = recuritEx;
// data.IF1 = if1;
// data.SF1 = sf1;
// if (hasFirstFluxDevice)
// {
// // xd100e ai5 == if1
// //
// // ai1 - gt1, ai2 - bt1
// //
// data.AI5 = Convert.ToSingle(if1);
// data.AI1 = Convert.ToSingle(GetGT1FromCRL_G(xd100eDevice));
// data.AI2 = Convert.ToSingle(GetBT1FromCRL_G(xd100eDevice));
// }
// data.DT = DateTime.Now;
// xd100eDevice.DeviceDataManager.Last = data;
// int deviceID = GuidHelper.ConvertToInt32(xd100eDevice.Guid);
// Console.WriteLine("write xd100e id: " + deviceID);
// DBI.Instance.InsertXd100eData(deviceID, data);
//}
}
}
}
private static List<Feature> ParseFeature(XElement source, IParseResult result)
{
List<Feature> features = new List<Feature>();
var featureElements = source.Elements("Feature");
if (featureElements.Any())
{
foreach (var featureElement in featureElements)
{
var feature = new Feature();
ParseResult error = new ParseResult(featureElement.Name.LocalName);
string val;
XElement node;
TryExecute(
() =>
{
val = ParseAttribute<string>(featureElement, "FeatureName");
Validate(() => Validator.HasValue(val));
feature.FeatureName = ParseEnum<FeatureName>(val);
}, "FeatureName", error);
TryExecute(
() =>
{
val = ParseAttribute<string>(featureElement, "UnitName");
if (!string.IsNullOrWhiteSpace(val))
feature.UnitName = ParseEnum<UnitType>(val);
}, "UnitName", error);
TryExecute(
() =>
{
val = ParseAttribute<string>(featureElement, "WheelType");
if (!string.IsNullOrWhiteSpace(val))
feature.WheelType = ParseEnum<WheelType>(val);
}, "WheelType", error);
TryExecute(
() =>
{
if (featureElement.HaveElement("ResponseTime"))
feature.ResponseTime = ParseResponseTime(featureElement, error).FirstOrDefault();
}, "ResponseTime", error);
feature.Specs = ParseSpecValue(featureElement, error);
feature.Slots = new List<Slot>();
var nodes = featureElement.Elements("Slot");
if (nodes.Any())
{
feature.Slots = nodes.SelectMany(n => ParseSlot(n, null, error)).ToList();
}
var mediaSlots = ParseMediaRangeInfo(featureElement, error);
feature.Slots.AddRange(mediaSlots.SelectMany(ms => ms.Value).ToList());
if (error.FieldsWithError.Count == 0)
features.Add(feature);
if (error.HaveError) result.ErrorList.Add(error);
}
}
return features;
}
private static CompoundStructure ParseCompoundSturcture(XElement source, IParseResult result)
{
XElement structureElement = source.Element("CompoundStructure");
if (structureElement == null) return null;
ParseResult error = new ParseResult(structureElement.Name.LocalName);
CompoundStructure structure = new CompoundStructure();
TryExecute(
() =>
{
XElement node;
string val;
if(structureElement.HaveElement("CellGeometry"))
{
node = structureElement.GetElement("CellGeometry", false);
TryExecute(
() =>
{
val = ParseAttribute<string>(node, "XCount");
Validate(() => Validator.HasValue(val));
structure.GeometryXCount = ParseValue<int>(val);
}, "XCount", error);
TryExecute(
() =>
{
val = ParseAttribute<string>(node, "YCount");
Validate(() => Validator.HasValue(val));
structure.GeometryYCount = ParseValue<int>(val);
}, "YCount", error);
}
if (structureElement.HaveElement("CellSize"))
{
node = structureElement.GetElement("CellSize", false);
TryExecute(
() =>
{
val = ParseAttribute<string>(node, "XSize");
Validate(() => Validator.HasValue(val));
structure.CellSizeX = ParseValue<int>(val);
}, "XSize", error);
TryExecute(
() =>
{
val = ParseAttribute<string>(node, "YSize");
Validate(() => Validator.HasValue(val));
structure.CellSizeY = ParseValue<int>(val);
}, "YSize", error);
}
if (structureElement.HaveElement("CellShape"))
{
TryExecute(
() =>
{
val = ParseElement<string>(structureElement, "CellShape");
Validate(() => Validator.HasValue(val));
structure.CellShape = ParseEnum<CellType>(val);
}, "CellShape", error);
}
}, "CompoundStructure", error);
if (error.HaveError) result.ErrorList.Add(error);
return structure;
}
private static List<DmxTimingSet> ParseDmxTimingSet(XElement source, IParseResult result)
{
List<DmxTimingSet> timingSets = new List<DmxTimingSet>();
var tsElements = source.Elements("DmxTimingSet");
if (tsElements.Any())
{
foreach (var tsElement in tsElements)
{
var timingSet = new DmxTimingSet();
ParseResult error = new ParseResult(tsElement.Name.LocalName);
string val;
XElement node;
TryExecute(
() =>
{
val = ParseAttribute<string>(tsElement, "HoldTime");
Validate(() => Validator.HasValue(val));
timingSet.HoldTime = ParseValue<int>(val);
}, "HoldTime", error);
TryExecute(
() =>
{
timingSet.ChannelSetting = ParseDmxChannelSetting(tsElement, error).FirstOrDefault();
}, "DmxChannelSetting", error);
if (error.FieldsWithError.Count == 0)
timingSets.Add(timingSet);
if (error.HaveError) result.ErrorList.Add(error);
}
}
return timingSets;
}
Action IRunnerRepository.FindRunner(IParseResult inResult, ConsoleLogEventHandler inEvent)
{
Action<IParseResult, ConsoleLogEventHandler> act;
if (mLookups.TryGetValue(inResult.GetType(), out act)) {
return () => {
act(inResult, inEvent);
};
}
throw new NotSupportedException(inResult.GetType().ToString());
}
private static DmxSpecification ParseDmxSpecification(XElement source, IParseResult result)
{
XElement dmxSpecElement = source.Element("DmxSpecification");
var dmxSpec = new DmxSpecification();
if (dmxSpecElement != null)
{
ParseResult error = new ParseResult(dmxSpecElement.Name.LocalName);
string val;
TryExecute(
() =>
{
val = ParseAttribute<string>(dmxSpecElement, "DmxFootprint");
Validate(() => Validator.HasValue(val));
dmxSpec.DmxFootprint = ParseValue<int>(val);
}, "DmxFootprint", error);
TryExecute(
() =>
{
if (dmxSpecElement.HaveElement("DmxPatchgroup"))
dmxSpec.PatchGroups = ParseDmxPatchgroup(dmxSpecElement, error);
}, "DmxPatchgroup", error);
TryExecute(
() =>
{
if (dmxSpecElement.HaveElement("DmxModuleDefinitions"))
dmxSpec.ModuleDefinitions = ParseDmxModuleDefinition(dmxSpecElement.Element("DmxModuleDefinitions"), error);
}, "DmxModuleDefinitions", error);
if(error.HaveError) result.ErrorList.Add(error);
}
return dmxSpec;
}
private static List<DmxChannelSetting> ParseDmxChannelSetting(XElement source, IParseResult result)
{
List<DmxChannelSetting> channelSettings = new List<DmxChannelSetting>();
var settingElements = source.Elements("DmxChannelSetting");
if (settingElements.Any())
{
foreach (var settingElement in settingElements)
{
var setting = new DmxChannelSetting();
ParseResult error = new ParseResult(settingElement.Name.LocalName);
string val;
TryExecute(
() =>
{
val = ParseAttribute<string>(settingElement, "ChannelNum");
Validate(() => Validator.HasValue(val));
setting.ChannelNum = ParseValue<int>(val);
}, "ChannelNum", error);
TryExecute(
() =>
{
val = ParseAttribute<string>(settingElement, "DmxValue");
Validate(() => Validator.HasValue(val));
if (HaveRangeValue(val))
{
setting.DmxValueRange = ParseRangeValue(val);
return;
}
setting.DmxValue = ParseValue<int>(val);
}, "DmxValue", error);
if (error.FieldsWithError.Count == 0)
channelSettings.Add(setting);
if (error.HaveError) result.ErrorList.Add(error);
}
}
return channelSettings;
}
private static List<DmxRangeSetCondition> ParseDmxRangeSetCondition(XElement source, IParseResult result)
{
List<DmxRangeSetCondition> setConditions = new List<DmxRangeSetCondition>();
var conditionElements = source.Elements("DmxRangeSetCondition");
if (conditionElements.Any())
{
string val;
foreach (XElement conditionElement in conditionElements)
{
var condition = new DmxRangeSetCondition();
ParseResult error = new ParseResult(conditionElement.Name.LocalName);
TryExecute(
() =>
{
val = ParseAttribute<string>(conditionElement, "ChannelNum");
Validate(() => Validator.HasValue(val));
Validate(() => Validator.IsMatch("\\d+", val));
condition.ChannelNum = ParseValue<int>(val);
}, "ChannelNum", error);
TryExecute(
() =>
{
var node = conditionElement.GetElement("DmxRange", true);
val = ParseAttribute<string>(node, "Range");
Validate(() => Validator.HasValue(val));
Validate(() => Validator.IsMatch("\\d+.{3}\\d+", val));
condition.DmxRange = ParseRangeValue(val);
}, "DmxRange", error);
if(error.FieldsWithError.Count == 0)
setConditions.Add(condition);
if (error.HaveError) result.ErrorList.Add(error);
}
}
return setConditions;
}
public override void OnProcessUpload(IDevice device, IParseResult pr)
{
// nothing
//
}
private static List<DmxRange> ParseDmxRange(XElement source, ConditionalDmxRangeSet rangeSet, IParseResult result)
{
List<DmxRange> dmxRanges = new List<DmxRange>();
var rangeElements = source.Elements("DmxRange");
if (rangeElements.Any())
{
foreach (var rangeElement in rangeElements)
{
var range = new DmxRange();
ParseResult error = new ParseResult(rangeElement.Name.LocalName);
string val;
TryExecute(
() =>
{
val = ParseAttribute<string>(rangeElement, "Range");
Validate(() => Validator.HasValue(val));
Validate(() => Validator.IsMatch("\\d+.{3}\\d+", val));
range.Range = ParseRangeValue(val);
}, "Range", error);
TryExecute(
() =>
{
if (rangeElement.HaveElement("DmxRangeLabel"))
{
range.RangeLabel = rangeElement.GetElementValue("DmxRangeLabel");
}
}, "DmxRangeLabel", error);
TryExecute(
() =>
{
range.FeatureRange = ParseFeatureRange(rangeElement, error);
}, "FeatureRange", error);
range.ConditionalRangeSet = rangeSet;
if (error.FieldsWithError.Count == 0)
dmxRanges.Add(range);
if (error.HaveError) result.ErrorList.Add(error);
}
}
return dmxRanges;
}
/// <summary> /// /// </summary> /// <param name="task"></param> /// <param name="pr"></param> public abstract void OnProcess(ITask task, IParseResult pr);
/// <summary>
///
/// </summary>
/// <param name="task"></param>
/// <param name="pr"></param>
public void Process(ITask task, IParseResult pr)
{
OnProcess(task, pr);
}
