/// <summary>Loads meta enum data from XML.</summary> public static MetaEnum LoadFromXml(XElement xml) { try { MetaEnum metaEnum = new MetaEnum(); metaEnum.Name = xml.HasAttribute("name") ? xml.Attribute("name").Value : ""; metaEnum.CanonicName = xml.HasAttribute("canonicName") ? xml.Attribute("canonicName").Value : ""; metaEnum.Namespace = xml.HasAttribute("namespace") ? xml.Attribute("namespace").Value : ""; metaEnum.IsFlags = xml.HasAttribute("isFlags") ? (bool)xml.Attribute("isFlags") : false; metaEnum.BaseType = xml.HasAttribute("baseType") ? xml.Attribute("baseType").Value : ""; // Load Enum Values XElement xValues = xml.Element("EnumValues"); if (xValues != null) { foreach (XElement xValue in xValues.Elements("EnumValue")) { string name = xValue.HasAttribute("name") ? xValue.Attribute("name").Value : ""; string valu = xValue.HasAttribute("value") ? xValue.Attribute("value").Value : ""; string desc = xValue.HasAttribute("description") ? xValue.Attribute("description").Value : ""; MetaEnumValue mev = new MetaEnumValue(name, valu, desc); metaEnum.EnumValues.Add(mev); } } return metaEnum; } catch (Exception) { return null; } }
static private void InputCase(XElement input, Dictionary <string, string> dic) { var name = (string)input.Attribute("name"); switch ((string)input.Attribute("type")) { case "checkbox": if (input.HasAttribute("checked")) { dic[name] = input.AttrStr("value"); } break; case "radio": if (input.HasAttribute("checked")) { dic[name] = input.AttrStr("value"); } break; default: //Console.WriteLine(input.Attribute("type")); dic[name] = input.AttrStr("value"); break; } }
/// <summary>Loads meta primitive data from XML.</summary> public static MetaPrimitive LoadFromXml(XElement xml) { try { MetaPrimitive prim = new MetaPrimitive(); prim.Name = xml.HasAttribute("name") ? xml.Attribute("name").Value : ""; prim.CanonicName = xml.HasAttribute("canonicName") ? xml.Attribute("canonicName").Value : ""; prim.Namespace = xml.HasAttribute("namespace") ? xml.Attribute("namespace").Value : ""; prim.IsNullable = xml.HasAttribute("isNullable") ? (bool)xml.Attribute("isNullable") : false; prim.TagName = xml.HasAttribute("tagName") ? xml.Attribute("tagName").Value : ""; //prim.BaseType = xml.HasAttribute("baseType") ? xml.Attribute("baseType").Value : ""; return prim; } catch (Exception) { return null; } }
internal override void LoadFromXml(XElement xRoot) { if(xRoot.HasAttribute(XmlConstants.Reference)) { XmlUserVariableReference bufferReference = new XmlUserVariableReference(xRoot); Name = bufferReference.UserVariable.Name; } else Name = xRoot.Value; }
public static bool CompareAttributeVal(this XElement me, string attributeName, string attributeValue, bool ignoreCase) { if (me.HasAttribute(attributeName)) { return(string.Compare(me.Attribute(attributeName).Value, attributeValue, ignoreCase ? StringComparison.CurrentCultureIgnoreCase : StringComparison.CurrentCulture) == 0); } else { return(false); } }
public static T ReadAttribute <T>(this XElement element, string attributeName) { if (TryReadAttribute(element, attributeName, out T result)) { return(result); } if (element.HasAttribute(attributeName)) { throw new InvalidCastException($"The value '{element.Attribute(attributeName).Value}' could not be converted to {typeof(T).Name}"); } throw new KeyNotFoundException($"The attribute '{attributeName}' was not found"); }
public void PublishXml(XElement xml) { if (xml.HasAttribute("minValue")) { double min = 0; double.TryParse(xml.GetAttribute("minValue"), out min); this.Minimum = min; } if (xml.HasAttribute("maxValue")) { double max = 0; double.TryParse(xml.GetAttribute("maxValue"), out max); this.Maximum = max; DoubleCollection dc = new DoubleCollection(); double d=0; while(d < max) { dc.Add(d); d++; } this.Ticks = dc; } if (xml.HasAttribute("step")) { double step = 1; double.TryParse(xml.GetAttribute("step"), out step); this.TickFrequency = step; } }
private string AttributeFor(XElement el, string attribute) { if (!el.HasAttribute(attribute)) throw new InvalidProjectFileComplaint(projectInfo); return el.Attribute(attribute).Value; }
public void Should_Handle_NotInitializedAttributes() { var element = new XElement("ServiceConfig"); int? delay = null; element.SetAttributeValue("PreShutdownDelay", delay); Assert.False(element.HasAttribute("PreShutdownDelay")); delay = 1000; element.SetAttributeValue("PreShutdownDelay", delay); Assert.True(element.HasAttribute("PreShutdownDelay")); ServiceSid serviceSid = null; element.SetAttributeValue("ServiceSid", serviceSid); Assert.False(element.HasAttribute("ServiceSid")); serviceSid = ServiceSid.none; element.SetAttributeValue("ServiceSid", serviceSid); Assert.True(element.HasAttribute("ServiceSid", value => value == "none")); serviceSid = new ServiceSid("0"); element.SetAttributeValue("ServiceSid", serviceSid); Assert.True(element.HasAttribute("ServiceSid", value => value == "0")); }
public static PhoneMetadata LoadCountryMetadata(String regionCode, XElement element, bool liteBuild) { String nationalPrefix = GetNationalPrefix(element); PhoneMetadata.Builder metadata = LoadTerritoryTagMetadata(regionCode, element, nationalPrefix); String nationalPrefixFormattingRule = GetNationalPrefixFormattingRuleFromElement(element, nationalPrefix); LoadAvailableFormats(metadata, element, nationalPrefix.ToString(), nationalPrefixFormattingRule.ToString(), element.HasAttribute(NATIONAL_PREFIX_OPTIONAL_WHEN_FORMATTING)); LoadGeneralDesc(metadata, element, liteBuild); return metadata.Build(); }
/// <summary>Loads meta class data from XML.</summary> public static MetaClass LoadFromXml(XElement xml) { try { MetaClass clazz = new MetaClass(); clazz.Name = xml.HasAttribute("name") ? xml.Attribute("name").Value : ""; clazz.CanonicName = xml.HasAttribute("canonicName") ? xml.Attribute("canonicName").Value : ""; clazz.Namespace = xml.HasAttribute("namespace") ? xml.Attribute("namespace").Value : ""; clazz.IdentityScope = xml.HasAttribute("identityScope") ? xml.Attribute("identityScope").Value : ""; clazz.OpCode = xml.HasAttribute("opCode") ? (uint)xml.Attribute("opCode") : 0; clazz.OpCodeHex = xml.HasAttribute("opCodeHex") ? xml.Attribute("opCodeHex").Value : ""; clazz.TagName = xml.HasAttribute("tagName") ? xml.Attribute("tagName").Value : ""; clazz.IsCoreClass = xml.HasAttribute("isCore") ? (bool)xml.Attribute("isCore") : false; clazz.IsAbstract = xml.HasAttribute("isAbstract") ? (bool)xml.Attribute("isAbstract") : false; clazz.BaseClass = xml.HasAttribute("baseClass") ? xml.Attribute("baseClass").Value : ""; clazz.Stereotype = xml.HasAttribute("stereotype") ? xml.Attribute("stereotype").Value : ""; // Load Documentation clazz.Documentation = Documentation.LoadFromXml(xml.Element("Documentation")); // Load Properties XElement xProperties = xml.Element("Properties"); if (xProperties != null) { foreach (XElement xProp in xProperties.Elements("Property")) { MetaProperty metaProp = MetaProperty.LoadFromXml(xProp); if (metaProp != null) { clazz.Properties.Add(metaProp); } } } return clazz; } catch (Exception) { return null; } }
/** * Returns the national prefix of the provided country element. */ // @VisibleForTesting public static String GetNationalPrefix(XElement element) { return element.HasAttribute(NATIONAL_PREFIX) ? element.GetAttribute(NATIONAL_PREFIX) : ""; }
private object _getValue(XElement element) { if (element.HasAttribute("value")) { return element.Get("value"); } if (!element.HasElements) { return element.Value; } var valueSet = new Dictionary<string, string>(); foreach (var child in element.Elements()) { var itemTag = child.Name.LocalName; if (itemTag != "Value") { throw new Exception("Unrecognized tag '{0}'".Substitute(itemTag)); } valueSet.Add(child.Get("name"), child.HasAttribute("value") ? child.Get("value") : child.Value); } return valueSet; }
/// <summary/> protected override void FromXmlOverride(XElement element) { base.FromXmlOverride(element); if (element.HasAttribute("operation")) { Operation = BplClass.Get(element.Get("operation")); } }
public static PhoneMetadata.Builder LoadTerritoryTagMetadata(String regionCode, XElement element, String nationalPrefix) { var metadata = new PhoneMetadata.Builder(); metadata.SetId(regionCode); metadata.SetCountryCode(int.Parse(element.GetAttribute(COUNTRY_CODE))); if (element.HasAttribute(LEADING_DIGITS)) metadata.SetLeadingDigits(ValidateRE(element.GetAttribute(LEADING_DIGITS))); metadata.SetInternationalPrefix(ValidateRE(element.GetAttribute(INTERNATIONAL_PREFIX))); if (element.HasAttribute(PREFERRED_INTERNATIONAL_PREFIX)) { String preferredInternationalPrefix = element.GetAttribute(PREFERRED_INTERNATIONAL_PREFIX); metadata.SetPreferredInternationalPrefix(preferredInternationalPrefix); } if (element.HasAttribute(NATIONAL_PREFIX_FOR_PARSING)) { metadata.SetNationalPrefixForParsing( ValidateRE(element.GetAttribute(NATIONAL_PREFIX_FOR_PARSING), true)); if (element.HasAttribute(NATIONAL_PREFIX_TRANSFORM_RULE)) { metadata.SetNationalPrefixTransformRule( ValidateRE(element.GetAttribute(NATIONAL_PREFIX_TRANSFORM_RULE))); } } if (!String.IsNullOrEmpty(nationalPrefix)) { metadata.SetNationalPrefix(nationalPrefix); if (!metadata.HasNationalPrefixForParsing) metadata.SetNationalPrefixForParsing(nationalPrefix); } if (element.HasAttribute(PREFERRED_EXTN_PREFIX)) { metadata.SetPreferredExtnPrefix(element.GetAttribute(PREFERRED_EXTN_PREFIX)); } if (element.HasAttribute(MAIN_COUNTRY_FOR_CODE)) { metadata.SetMainCountryForCode(true); } if (element.HasAttribute(LEADING_ZERO_POSSIBLE)) { metadata.SetLeadingZeroPossible(true); } return metadata; }
/// <summary>Loads meta property data from XML.</summary> public static MetaProperty LoadFromXml(XElement xml) { try { MetaProperty prop = new MetaProperty(); prop.Name = xml.HasAttribute("name") ? xml.Attribute("name").Value : ""; prop.CanonicName = xml.HasAttribute("canonicName") ? xml.Attribute("canonicName").Value : ""; prop.DataType = xml.HasAttribute("dataType") ? xml.Attribute("dataType").Value : ""; prop.IsPrimitive = xml.HasAttribute("isPrimitive") ? (bool)xml.Attribute("isPrimitive") : false; prop.IsReadOnly = xml.HasAttribute("isReadOnly") ? (bool)xml.Attribute("isReadOnly") : false; prop.IsScalar = xml.HasAttribute("isScalar") ? (bool)xml.Attribute("isScalar") : false; prop.IsArray = xml.HasAttribute("isArray") ? (bool)xml.Attribute("isArray") : false; prop.IsCollection = xml.HasAttribute("isCollection") ? (bool)xml.Attribute("isCollection") : false; // Load Documentation prop.Documentation = Documentation.LoadFromXml(xml.Element("Documentation")); return prop; } catch (Exception) { return null; } }
/** * Extracts the available formats from the provided DOM element. If it does not contain any * nationalPrefixFormattingRule, the one passed-in is retained. The nationalPrefix, * nationalPrefixFormattingRule and nationalPrefixOptionalWhenFormatting values are provided from * the parent (territory) element. */ // @VisibleForTesting public static void LoadAvailableFormats(PhoneMetadata.Builder metadata, XElement element, String nationalPrefix, String nationalPrefixFormattingRule, bool nationalPrefixOptionalWhenFormatting) { String carrierCodeFormattingRule = ""; if (element.HasAttribute(CARRIER_CODE_FORMATTING_RULE)) { carrierCodeFormattingRule = ValidateRE( GetDomesticCarrierCodeFormattingRuleFromElement(element, nationalPrefix)); } var numberFormatElements = element.GetElementsByTagName(NUMBER_FORMAT); bool hasExplicitIntlFormatDefined = false; int numOfFormatElements = numberFormatElements.Count(); if (numOfFormatElements > 0) { foreach (XElement numberFormatElement in numberFormatElements) { var format = new NumberFormat.Builder(); if (numberFormatElement.HasAttribute(NATIONAL_PREFIX_FORMATTING_RULE)) { format.SetNationalPrefixFormattingRule( GetNationalPrefixFormattingRuleFromElement(numberFormatElement, nationalPrefix)); format.SetNationalPrefixOptionalWhenFormatting( numberFormatElement.HasAttribute(NATIONAL_PREFIX_OPTIONAL_WHEN_FORMATTING)); } else { format.SetNationalPrefixFormattingRule(nationalPrefixFormattingRule); format.SetNationalPrefixOptionalWhenFormatting(nationalPrefixOptionalWhenFormatting); } if (numberFormatElement.HasAttribute("carrierCodeFormattingRule")) { format.SetDomesticCarrierCodeFormattingRule(ValidateRE( GetDomesticCarrierCodeFormattingRuleFromElement( numberFormatElement, nationalPrefix))); } else { format.SetDomesticCarrierCodeFormattingRule(carrierCodeFormattingRule); } // Extract the pattern for the national format. String nationalFormat = LoadNationalFormat(metadata, numberFormatElement, format); metadata.AddNumberFormat(format); if (LoadInternationalFormat(metadata, numberFormatElement, nationalFormat)) { hasExplicitIntlFormatDefined = true; } } // Only a small number of regions need to specify the intlFormats in the xml. For the majority // of countries the intlNumberFormat metadata is an exact copy of the national NumberFormat // metadata. To minimize the size of the metadata file, we only keep intlNumberFormats that // actually differ in some way to the national formats. if (!hasExplicitIntlFormatDefined) { metadata.ClearIntlNumberFormat(); } } }
/// <summary>Loads meta model from XML.</summary> public static MetaPackage LoadFromXml(XElement xml) { MetaPackage package = new MetaPackage(); package.Name = xml.HasAttribute("name") ? xml.Attribute("name").Value : ""; package.CanonicName = xml.HasAttribute("canonicName") ? xml.Attribute("canonicName").Value : ""; package.Namespace = xml.HasAttribute("namespace") ? xml.Attribute("namespace").Value : ""; package.IsRoot = xml.HasAttribute("isRoot") ? (bool)xml.Attribute("isRoot") : false; // Load documentation package.Documentation = Documentation.LoadFromXml(xml.Element("Documentation")); // Load classes XElement xClasses = xml.Element("Classes"); if (xClasses != null) { foreach (XElement xClass in xClasses.Elements("Class")) { MetaClass metaClass = MetaClass.LoadFromXml(xClass); if (metaClass != null) { package.Classes.Add(metaClass); } } } // Load primitives XElement xPrimitives = xml.Element("Primitives"); if (xPrimitives != null) { foreach (XElement xPrimitive in xPrimitives.Elements("Primitive")) { MetaPrimitive metaPrimitive = MetaPrimitive.LoadFromXml(xPrimitive); if (metaPrimitive != null) { package.Primitives.Add(metaPrimitive); } } } // Load enums XElement xEnums = xml.Element("Enums"); if (xEnums != null) { foreach (XElement xEnum in xEnums.Elements("Enum")) { MetaEnum mEnum = MetaEnum.LoadFromXml(xEnum); if (mEnum != null) { package.Enums.Add(mEnum); } } } // Load sub packages XElement xPackages = xml.Element("Packages"); if (xPackages != null) { foreach (XElement xPackage in xPackages.Elements("Package")) { MetaPackage subPackage = MetaPackage.LoadFromXml(xPackage); if (subPackage != null) { package.Packages.Add(subPackage); } } } return package; }
public static bool HasAttribute(this XElement element, string name) { return(element.HasAttribute(name, true)); }