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; }
public Manufacturers() { Error = new ParseResult("Manufacturers"); }
private static RdmSpecification ParseRdmSpecification(XElement source, IParseResult result) { XElement rdmSpecElement = source.Element("RdmSpecification"); var rdmSpec = new RdmSpecification(); if (rdmSpecElement != null) { ParseResult error = new ParseResult(rdmSpecElement.Name.LocalName); string val; XElement node; } return rdmSpec; }
private static FixtureModel ParseFixtureModel(XElement fixtureElement) { ParseResult error = new ParseResult(fixtureElement.Name.LocalName); FixtureModel fixture = new FixtureModel(); string val; TryExecute( () => { val = ParseAttribute<string>(fixtureElement, "ManuId"); Validate(() => Validator.HasValue(val)); Validate(() => Validator.IsLengthBetween(3, 3, val)); fixture.ManuId = int.Parse(val); }, "ManuId", error); TryExecute( () => { val = ParseAttribute<string>(fixtureElement, "ModelId"); Validate(() => Validator.HasValue(val)); Validate(() => Validator.IsLengthBetween(3, 3, val)); fixture.ModelId = int.Parse(val); }, "ModelId", error); TryExecute( () => { val = ParseAttribute<string>(fixtureElement, "ModeId"); Validate(() => Validator.HasValue(val)); Validate(() => Validator.IsLengthBetween(2, 2, val)); fixture.ModeId = int.Parse(val); }, "ModeId", error); TryExecute( () => { val = ParseAttribute<string>(fixtureElement, "ModeId_2"); Validate(() => Validator.HasValue(val)); Validate(() => Validator.IsLengthBetween(2, 2, val)); fixture.ModeId2 = int.Parse(val); }, "ModeId_2", error); TryExecute( () => { val = ParseElement<string>(fixtureElement, "ModelName"); Validate(() => Validator.HasValue(val)); fixture.Name = val; }, "ModelName", error); TryExecute( () => { val = ParseElement<string>(fixtureElement, "ModeName"); Validate(() => Validator.HasValue(val)); fixture.ModeName = val; }, "ModeName", error); TryExecute( () => { val = ParseElement<string>(fixtureElement, "PersonalityName_8"); Validate(() => Validator.HasValue(val)); Validate(() => Validator.IsLengthBetween(1, 8, val)); fixture.PersonalityName = val; }, "PersonalityName_8", error); TryExecute( () => { val = ParseElement<string>(fixtureElement, "DocumentationVersion"); Validate(() => Validator.HasValue(val)); fixture.DocumentationVersion = val; }, "DocumentationVersion", error); TryExecute( () => { val = ParseElement<string>(fixtureElement, "UserNotes"); fixture.UserNotes = val; }, "UserNotes", error); TryExecute( () => { val = ParseElement<string>(fixtureElement, "KnownIssues"); fixture.KnownIssues = ParseList(val); }, "KnownIssues", error); fixture.Physical = ParsePhysicalProperties(fixtureElement, error); fixture.TestingInfo = ParseTestingInfo(fixtureElement, error); fixture.DmxSpecification = ParseDmxSpecification(fixtureElement, error); fixture.RdmSpefication = ParseRdmSpecification(fixtureElement, error); fixture.Error = error; return fixture; }
private static PhysicalProperties ParsePhysicalProperties(XElement source, ParseResult result) { XElement propertiesElement = source.Element("PhysicalProperties"); var properties = new PhysicalProperties(); if (propertiesElement != null) { ParseResult error = new ParseResult(propertiesElement.Name.LocalName); string val; XElement node; TryExecute( () => { val = ParseElement<string>(propertiesElement, "PhysicalType"); Validate(() => Validator.HasValue(val)); properties.Type = ParseEnum<PhysicalType>(val); }, "PhysicalType", error); TryExecute( () => { val = ParseElement<string>(propertiesElement, "LightGeneration"); Validate(() => Validator.HasValue(val)); properties.LightGeneration = ParseEnum<LightGeneration>(val); }, "LightGeneration", error); TryExecute( () => { val = ParseElement<string>(propertiesElement, "MovementType"); Validate(() => Validator.HasValue(val)); properties.MovementType = ParseEnum<MovementType>(val); }, "MovementType", error); TryExecute( () => { val = ParseElement<string>(propertiesElement, "BeamType"); Validate(() => Validator.HasValue(val)); properties.BeamType = ParseEnum<BeamType>(val); }, "BeamType", error); TryExecute( () => { if (!propertiesElement.HaveElement("ColourMixing")) return; node = propertiesElement.GetElement("ColourMixing", false); TryExecute( () => { val = ParseAttribute<string>(node, "MixingType"); Validate(() => Validator.HasValue(val)); properties.ColourMixingType = ParseEnum<MixingType>(val); }, "MixingType", error); }, "ColourMixing", error); TryExecute( () => { if (propertiesElement.HaveElement("CompoundStructure")) properties.CompoundStructure = ParseCompoundSturcture(propertiesElement, error); }, "CompoundStructure", error); TryExecute( () => { if (propertiesElement.HaveElement("FixtureDimensions")) properties.Dimension = ParserFixtureDimension(propertiesElement, error); }, "FixtureDimensions", error); TryExecute( () => { if (propertiesElement.HaveElement("FixtureMass")) properties.FixtureMass = ParseValue<float>(propertiesElement.GetElementValue("FixtureMass")); }, "FixtureMass", error); TryExecute( () => { if (propertiesElement.HaveElement("FixtureBeamAngle")) properties.BeamAngle = ParserFixtureBeamAngle(propertiesElement, error); }, "FixtureBeamAngle", error); node = propertiesElement.GetElement("ValueMap", false); if (node != null) properties.ValueMaps = ParseFeature(node, error); node = propertiesElement.GetElement("SlotMap", false); if (node != null) properties.SlotMaps = ParseFeature(node, error); if(error.HaveError) result.ErrorList.Add(error); } else { result.FieldsWithError["PhysicalProperties"] = "Undefined"; } return properties; }
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<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 List<SpecValue> ParseSpecValue(XElement source, IParseResult result) { List<SpecValue> specs = new List<SpecValue>(); var specElements = source.Elements("SpecValue"); if (specElements.Any()) { foreach (var specElement in specElements) { var spec = new SpecValue(); ParseResult error = new ParseResult(specElement.Name.LocalName); string val; XElement node; TryExecute( () => { val = ParseAttribute<string>(specElement, "PercentValue"); Validate(() => Validator.HasValue(val)); spec.PercentValue = ParseValue<int>(val); }, "PercentValue", error); TryExecute( () => { val = ParseAttribute<string>(specElement, "UnitValue"); Validate(() => Validator.HasValue(val)); spec.UnitValue = ParseValue<float>(val); }, "UnitValue", error); if (error.FieldsWithError.Count == 0) specs.Add(spec); if (error.HaveError) result.ErrorList.Add(error); } } return specs; }
private static TestingInfo ParseTestingInfo(XElement source, ParseResult result) { XElement tinfoElement = source.Element("TestingInfo"); var testInfo = new TestingInfo(); if (tinfoElement != null) { ParseResult error = new ParseResult(tinfoElement.Name.LocalName); string val; XElement node; TryExecute( () => { val = ParseElement<string>(tinfoElement, "DmxStatus"); Validate(() => Validator.HasValue(val)); testInfo.DmxStatus = ParseEnum<DmxStatus>(val); }, "DmxStatus", error); TryExecute( () => { val = ParseElement<string>(tinfoElement, "RdmStatus"); Validate(() => Validator.HasValue(val)); testInfo.RdmStatus = ParseEnum<RdmStatus>(val); }, "RdmStatus", error); TryExecute( () => { val = ParseElement<string>(tinfoElement, "FirmwareVersionTested"); Validate(() => Validator.HasValue(val)); testInfo.FirmwareVersionTested = val; }, "FirmwareVersionTested", error); TryExecute( () => { val = ParseElement<string>(tinfoElement, "ColourMixStatus"); Validate(() => Validator.HasValue(val)); testInfo.ColourMixStatus = ParseEnum<ColourMixStatus>(val); }, "ColourMixStatus", error); TryExecute( () => { val = ParseElement<string>(tinfoElement, "TestingNotes"); testInfo.TestingNotes = ParseList(val); }, "TestingNotes", error); if (error.HaveError) result.ErrorList.Add(error); } else { result.FieldsWithError["TestingInfo"] = "Undefined"; } return testInfo; }
private static Dimension ParserFixtureDimension(XElement source, IParseResult result) { XElement dimensionElement = source.Element("FixtureDimensions"); var dimension = new Dimension(); if (dimensionElement != null) { ParseResult error = new ParseResult(dimensionElement.Name.LocalName); string val; TryExecute( () => { val = ParseAttribute<string>(dimensionElement, "XSize"); Validate(() => Validator.HasValue(val)); dimension.X = ParseValue<float>(val); }, "XSize", error); TryExecute( () => { val = ParseAttribute<string>(dimensionElement, "YSize"); Validate(() => Validator.HasValue(val)); dimension.Y = ParseValue<float>(val); }, "YSize", error); TryExecute( () => { val = ParseAttribute<string>(dimensionElement, "ZSize"); Validate(() => Validator.HasValue(val)); dimension.Z = ParseValue<float>(val); }, "ZSize", error); if (error.HaveError) result.ErrorList.Add(error); } return dimension; }
/// <summary> /// Some slot are inside MediaRange tag. Parent tag mapped in property /// E:\Workspace\Mike\FixtureLibrary\source\data\fixtures\clay_paky\goldenscan_3_8_ch\goldenscan_3_8_ch.xml /// </summary> /// <param name="source"></param> /// <param name="parentMediaRange"></param> /// <returns></returns> private static List<Slot> ParseSlot(XElement source, MediaRangeInfo parentMediaRange, IParseResult result) { List<Slot> slots = new List<Slot>(); var slotElements = source.Elements("Slot"); if (slotElements.Any()) { foreach (var slotElement in slotElements) { var slot = new Slot(); slot.MediaRangeInfo = parentMediaRange; ParseResult error = new ParseResult(slotElement.Name.LocalName); string val; TryExecute( () => { val = ParseAttribute<string>(slotElement, "SlotNumber"); Validate(() => Validator.HasValue(val)); slot.Number = ParseValue<int>(val); }, "SlotNumber", error); TryExecute( () => { val = ParseAttribute<string>(slotElement, "LocalName"); Validate(() => Validator.HasValue(val)); slot.Name = val; }, "LocalName", error); TryExecute( () => { val = ParseAttribute<string>(slotElement, "MediaName"); Validate(() => Validator.HasValue(val)); slot.MediaName = val; }, "MediaName", error); if (error.FieldsWithError.Count == 0) slots.Add(slot); if (error.HaveError) result.ErrorList.Add(error); } } return slots; }
private static Dictionary<ConditionalDmxRangeSet, List<DmxRange>> ParseConditionalDmxRangeSet(XElement source, IParseResult result) { Dictionary<ConditionalDmxRangeSet,List<DmxRange>> rangeSets = new Dictionary<ConditionalDmxRangeSet, List<DmxRange>>(); var rangeSetElements = source.Elements("ConditionalDmxRangeSet"); if (rangeSetElements.Any()) { string val; foreach (XElement rangeSetElement in rangeSetElements) { var rangeSet = new ConditionalDmxRangeSet(); ParseResult error = new ParseResult(rangeSetElement.Name.LocalName); TryExecute( () => { rangeSet.RangeSetCondition = ParseDmxRangeSetCondition(rangeSetElement, error).FirstOrDefault(); }, "DmxRangeSetCondition", error); if (error.FieldsWithError.Count == 0) { rangeSets[rangeSet] = ParseDmxRange(rangeSetElement, rangeSet, error); } if (error.HaveError) result.ErrorList.Add(error); } } return rangeSets; }
private static BeamAngle ParserFixtureBeamAngle(XElement source, IParseResult result) { XElement angleElement = source.Element("FixtureBeamAngle"); var angle = new BeamAngle(); if (angleElement != null) { ParseResult error = new ParseResult(angleElement.Name.LocalName); string val; TryExecute( () => { val = ParseAttribute<string>(angleElement, "Angle"); Validate(() => Validator.HasValue(val)); angle.Angle = ParseValue<float>(val); }, "Angle", error); if (error.HaveError) result.ErrorList.Add(error); } return angle; }
private static List<ResponseTime> ParseResponseTime(XElement source, IParseResult result) { List<ResponseTime> responseTimes = new List<ResponseTime>(); var rtimeElements = source.Elements("ResponseTime"); if (rtimeElements.Any()) { foreach (var rtimeElement in rtimeElements) { var time = new ResponseTime(); ParseResult error = new ParseResult(rtimeElement.Name.LocalName); string val; TryExecute( () => { val = ParseAttribute<string>(rtimeElement, "Calibrated"); Validate(() => Validator.HasValue(val)); time.Calibrated = ParseValue<float>(val); }, "Calibrated", error); if (error.FieldsWithError.Count == 0) responseTimes.Add(time); if (error.HaveError) result.ErrorList.Add(error); } } return responseTimes; }
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; }
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; }
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; }
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<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; }
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<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; }
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 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; }
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; }
public static Manufacturers ParseManufacturers(string filename, bool removeTestData = true) { XDocument doc = XDocument.Load(new StreamReader(filename)); Manufacturers manufacturersRoot = new Manufacturers(); var root = doc.Element("Manufacturers"); var manufactrerNodes = root.Elements("Manufacturer"); ParseRevisions(root, manufacturersRoot); List<Manufacturer> manufactrers = new List<Manufacturer>(); string val; Manufacturer manufacturer; ParseResult error; foreach (XElement manufactrerNode in manufactrerNodes) { manufacturer = new Manufacturer(); error = new ParseResult(manufactrerNode.Name.LocalName); TryExecute( () => { val = ParseAttribute<string>(manufactrerNode, "ManuId"); if (Validate(() => Validator.HasValue(val)).IsSuccess) { Validate(() => Validator.IsLengthBetween(3, 3, val)); Validate(() => Validator.IsMatch("^\\d{3}", val)); Validate(() => Validator.Conatins(manufactrers, (m) => m.ManuId.ToString() == val, m => string.Format("Same ManuId as {0}", m.ManufacturerName))); manufacturer.ManuId = int.Parse(val); } }, "ManuId", error); TryExecute( () => { val = ParseElement<string>(manufactrerNode, "ManufacturerName"); if (Validate(() => Validator.HasValue(val)).IsSuccess) { Validate(() => Validator.IsMinLength(1, val)); Validate(() => Validator.Conatins(manufactrers, (m) => m.ManufacturerName == val, m => string.Format("Same ManufacturerName as {0}", m.ManuId))); manufacturer.ManufacturerName = val; } }, "ManufacturerName", error); TryExecute( () => { val = ParseElement<string>(manufactrerNode, "ManufacturerName_8"); if (Validate(() => Validator.HasValue(val)).IsSuccess) { Validate(() => Validator.IsLengthBetween(1, 8, val)); Validate(() => Validator.Conatins(manufactrers, (m) => m.ManufacturerName8 == val, m => string.Format("Same ManufacturerName_8 as {0}", m.ManuId))); manufacturer.ManufacturerName8 = val; } }, "ManufacturerName_8", error); TryExecute( () => { val = ParseElement<string>(manufactrerNode, "ManufacturerName_3"); if (Validate(() => Validator.HasValue(val)).IsSuccess) { Validate(() => Validator.IsLengthBetween(1, 3, val)); Validate(() => Validator.Conatins(manufactrers, (m) => m.ManufacturerName3 == val, m => string.Format("Same ManufacturerName_3 as {0}", m.ManuId))); manufacturer.ManufacturerName3 = val; } }, "ManufacturerName_3", error); TryExecute( () => { val = ParseElement<string>(manufactrerNode, "ManufacturerDirectory"); if (!Validate(() => Validator.HasValue(val)).IsSuccess) return; Validate(() => Validator.IsMinLength(1, val)); if (Regex.IsMatch(val, "[A-Z]", RegexOptions.None)) throw new Exception("Contains capital letter"); if (val.Contains(" ")) throw new Exception("Contains space letter"); Validate(() => Validator.ContainIllegelCharacter("[^a-z0-9_]", val)); Validate(() => Validator.Conatins(manufactrers, (m) => m.ManufacturerDirectory == val, m => string.Format("Same ManufacturerDirectory as {0}", m.ManuId))); manufacturer.ManufacturerDirectory = val; }, "ManufacturerDirectory", error); TryExecute(() => { val = ParseElement<string>(manufactrerNode, "ESTAId"); // optinal element if (!string.IsNullOrWhiteSpace(val)) { Validate(() => Validator.IsLengthBetween(4, 4, val)); Validate(() => Validator.ContainIllegelCharacter("[^A-F0-9]", val)); Validate(() => Validator.Conatins(manufactrers, (m) => m.ESTAId == val, m => string.Format("Same ESTAId as {0}", m.ManuId))); manufacturer.ESTAId = val; } }, "ESTAId", error); if (error.FieldsWithError.Count > 0) manufacturersRoot.Error.ErrorList.Add(error); else manufactrers.Add(manufacturer); } if (removeTestData) { manufactrers = manufactrers.Where(x => x.ManuId < 900).ToList(); } manufacturersRoot.ManufacturerList = manufactrers; return manufacturersRoot; }
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 static MediaRange ParseMediaRange(string filename, bool removeTestData = true) { var directory = Path.GetDirectoryName(filename); var files = Directory.GetFiles(directory).ToDictionary(f => Path.GetFileNameWithoutExtension(f), f => Path.GetFileName(f)); XDocument doc = XDocument.Load(new StreamReader(filename)); var mediaRange = new MediaRange(); var root = doc.Element("MediaRange"); var mediaNodes = root.Elements("Media"); ParseRevisions(root, mediaRange); XElement node; string val; Media media; ParseResult error; string mediaRangePrefix = string.Empty; TryExecute(() => { val = ParseElement<string>(root, "RangeName"); Validate(() => Validator.HasValue(val)); mediaRange.Name = val; }, "RangeName", mediaRange.Error); TryExecute(() => { val = ParseElement<string>(root, "MediaType"); if(!Validate(() => Validator.HasValue(val)).IsSuccess) return; mediaRange.MediaType = ParseEnum<MediaType>(val); }, "MediaType", mediaRange.Error); TryExecute(() => { val = ParseAttribute<string>(root, "ManuId"); if(!Validate(() => Validator.HasValue(val)).IsSuccess) return; Validate(() => Validator.IsLengthBetween(3, 3, val)); Validate(() => Validator.IsMatch("^\\d{3}", val)); mediaRange.ManuId = int.Parse(val); mediaRangePrefix = val; }, "ManuId", mediaRange.Error); TryExecute(() => { val = ParseAttribute<string>(root, "RangeId"); if(!Validate(() => Validator.HasValue(val)).IsSuccess) return; Validate(() => Validator.IsLengthBetween(3, 3, val)); Validate(() => Validator.IsMatch("^\\d{3}", val)); mediaRange.RangeId = int.Parse(val); mediaRangePrefix += val; }, "RangeId", mediaRange.Error); foreach (XElement mediaNode in mediaNodes) { media = new Media(); error = new ParseResult(mediaNode.Name.LocalName); TryExecute(() => { val = ParseAttribute<string>(mediaNode, "MediaId"); if(!Validate(() => Validator.HasValue(val)).IsSuccess) return; Validate(() => Validator.IsLengthBetween(2, 2, val)); Validate(() => Validator.IsMatch("^\\d{2}", val)); media.Id = GetCanonicalized(val); }, "MediaId", error); TryExecute(() => { val = ParseAttribute<string>(mediaNode, "MediaName"); if(!Validate(() => Validator.HasValue(val)).IsSuccess) return; Validate(() => Validator.IsMinLength(1, val)); media.Name = val; }, "MediaName", error); TryExecute( () => { // ensure child node exist node = mediaNode.GetElement("LithoImage", true); TryExecute(() => { val = ParseAttribute<string>(node, "BaseImage"); media.BaseImage = ParseEnum<BaseImage>(val); }, "BaseImage", error); TryExecute(() => { val = ParseAttribute<string>(node, "ImageSize"); media.Size = ParseEnum<ImageSize>(val); }, "ImageSize", error); TryExecute(() => { val = ParseAttribute<string>(node, "RepeatQuantity"); if (!Validate(() => Validator.HasValue(val)).IsSuccess) return; media.RepeatQuantity = val; }, "BaseImage", error); TryExecute(() => { val = ParseAttribute<string>(node, "RepeatPattern"); media.RepeatPattern = ParseEnum<RepeatPattern>(val); }, "RepeatPattern", error); }, "LithoImage", error); TryExecute( () => { // ensure child node exist node = mediaNode.GetElement("LithoColour", true); TryExecute(() => { val = ParseAttribute<string>(node, "ImageType"); media.ImageType = ParseEnum<ImageType>(val); }, "ImageType", error); TryExecute(() => { val = ParseAttribute<string>(node, "ImageColour"); media.ImageColour = ParseEnum<ImageColour>(val); }, "ImageColour", error); }, "LithoColour", error); TryExecute(() => { if (files.ContainsKey(mediaRangePrefix + media.Id)) media.ImageName = files[mediaRangePrefix + media.Id]; }, null, null); if (error.FieldsWithError.Count > 0) mediaRange.Error.ErrorList.Add(error); else mediaRange.Media.Add(media); } return mediaRange; }
public FixtureModel() { Error = new ParseResult("FixtureModel"); }