/// <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));
}
