private static PhoneNumberElementType GetTypeByNode(XmlAttribute node)
 {
     var str = node.InnerText;
     switch (str)
     {
     case "international-prefix":
         return PhoneNumberElementType.InternationalPrefix;
     case "country-prefix":
         return PhoneNumberElementType.CountryPrefix;
     case "national-prefix":
         return PhoneNumberElementType.NationalPrefix;
     case "unknown-national-prefix":
         return PhoneNumberElementType.UnknownNationalPrefix;
     case "national-code":
         return PhoneNumberElementType.NationalCode;
     case "area-code":
         return PhoneNumberElementType.AreaCode;
     case "local-number":
         return PhoneNumberElementType.LocalNumber;
     default:
         throw new MalformedXMLException (
             "The XML Received from Time and Date did not include an object name which complies with an AstronomyObjectType enum: " +
             str
         );
     }
 }

        /// <summary>
        /// Validates the XML any attributes.
        /// </summary>
        /// <param name="anyAttributes">Any attributes.</param>
        public void ValidateXmlAnyAttributes(XmlAttribute[] anyAttributes)
        {
            if (anyAttributes == null)
            {
                throw new ArgumentNullException("anyAttributes");
            }

            if (anyAttributes.Length == 0)
            {
                return;
            }

            foreach (var attr in anyAttributes)
            {
                if (!Saml20Utils.ValidateRequiredString(attr.Prefix))
                {
                    throw new Saml20FormatException("Attribute extension xml attributes MUST BE namespace qualified");
                }

                foreach (var samlns in Saml20Constants.SamlNamespaces)
                {
                    if (attr.NamespaceURI == samlns)
                    {
                        throw new Saml20FormatException("Attribute extension xml attributes MUST NOT use a namespace reserved by SAML");
                    }
                }
            }
        }

        public void Serialize(XmlElement node)
        {
            if (ShouldIgnore(node))
                return;

            Serialize(BEGIN_ELEMENT);
            Serialize(node.NamespaceURI);
            Serialize(node.LocalName);

            var attrs = new XmlAttribute[node.Attributes.Count];
            node.Attributes.CopyTo(attrs, 0);

            Array.Sort(attrs, new AttributeComparer());

            foreach (var attr in attrs) {
                Serialize(attr);
            }

            Serialize(END_ATTRIBUTES);

            foreach (XmlNode child in node.ChildNodes) {
                if (child is XmlElement) {
                    Serialize(child as XmlElement);
                } else {
                    Serialize(child as XmlCharacterData);
                }
            }

            Serialize(END_ELEMENT);
        }

 protected override void InitAtrrib(XmlAttribute Attr)
 {
     if(Attr.Name == "digits")
         Digits	= byte.Parse(Attr.Value);
     else if(Attr.Name == "magnitude")
         Magnitude	= short.Parse(Attr.Value);
 }

        void IHasAttribute.InitAtrribute(XmlAttribute Attr)
        {
            switch(Attr.Name)
            {
                case "mips_generate":
                    MipGenerate	= bool.Parse(Attr.Value);
                    break;

                case "array_index":
                    ArrayIndex	= uint.Parse(Attr.Value);
                    break;

                case "mip_index":
                    MipIndex	= uint.Parse(Attr.Value);
                    break;

                case "depth":
                    Depth	= uint.Parse(Attr.Value);
                    break;

                case "face":
                    Face	= (CubeFace)Enum.Parse(typeof(CubeFace),Attr.Value);
                    break;

                default:
                    throw new Exception("Invalid Atrribute");
            }
        }

 /// <summary>
 /// Processes an attribute for the Compiler.
 /// </summary>
 /// <param name="sourceLineNumbers">Source line number for the parent element.</param>
 /// <param name="parentElement">Parent element of element to process.</param>
 /// <param name="attribute">Attribute to process.</param>
 /// <param name="contextValues">Extra information about the context in which this element is being parsed.</param>
 public override void ParseAttribute(SourceLineNumberCollection sourceLineNumbers, XmlElement parentElement, XmlAttribute attribute, Dictionary<string, string> contextValues)
 {
     switch (parentElement.LocalName)
     {
         case "ExePackage":
         case "MsiPackage":
         case "MspPackage":
         case "MsuPackage":
             string packageId;
             if (!contextValues.TryGetValue("PackageId", out packageId) || String.IsNullOrEmpty(packageId))
             {
                 this.Core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, parentElement.LocalName, "Id", attribute.LocalName));
             }
             else
             {
                 switch (attribute.LocalName)
                 {
                     case "PrereqSupportPackage":
                         if (YesNoType.Yes == this.Core.GetAttributeYesNoValue(sourceLineNumbers, attribute))
                         {
                             Row row = this.Core.CreateRow(sourceLineNumbers, "MbaPrerequisiteSupportPackage");
                             row[0] = packageId;
                         }
                         break;
                     default:
                         this.Core.UnexpectedAttribute(sourceLineNumbers, attribute);
                         break;
                 }
             }
                 break;
         case "Variable":
             // at the time the extension attribute is parsed, the compiler might not yet have
             // parsed the Name attribute, so we need to get it directly from the parent element.
             string variableName = parentElement.GetAttribute("Name");
             if (String.IsNullOrEmpty(variableName))
             {
                 this.Core.OnMessage(WixErrors.ExpectedParentWithAttribute(sourceLineNumbers, "Variable", "Overridable", "Name"));
             }
             else
             {
                 switch (attribute.LocalName)
                 {
                     case "Overridable":
                         if (YesNoType.Yes == this.Core.GetAttributeYesNoValue(sourceLineNumbers, attribute))
                         {
                             Row row = this.Core.CreateRow(sourceLineNumbers, "WixStdbaOverridableVariable");
                             row[0] = variableName;
                         }
                         break;
                     default:
                         this.Core.UnexpectedAttribute(sourceLineNumbers, attribute);
                         break;
                 }
             }
             break;
         default:
             this.Core.UnexpectedAttribute(sourceLineNumbers, attribute);
             break;
     }
 }

        public static string GetValueAsString(XmlAttribute attribute, string defaultValue)
        {
            if (attribute == null)
                return defaultValue;

            return Mask.EmptyString(attribute.Value, defaultValue);
        }

        private string GetXmlAttributeAsString(XmlAttribute attribute) {

            if (attribute == null) return "";

            return attribute.Value.Trim();

        }

 internal ConditionEvaluationState(XmlAttribute conditionAttribute, Expander expanderToUse, Hashtable conditionedPropertiesInProject, string parsedCondition)
 {
     this.conditionAttribute = conditionAttribute;
     this.expanderToUse = expanderToUse;
     this.conditionedPropertiesInProject = conditionedPropertiesInProject;
     this.parsedCondition = parsedCondition;
 }

 protected override void ExecuteCore(XmlAttribute attribute)
 {
     var data = string.Format("{0}=\"{1}\"", attribute.Name, attribute.Value);
     var section = attribute.OwnerDocument.CreateCDataSection(data);
     attribute.OwnerElement.PrependChild(section);
     attribute.OwnerElement.Attributes.Remove(attribute);
 }

 /// <summary>
 /// Processes an attribute for the Compiler.
 /// </summary>
 /// <param name="sourceLineNumbers">Source line number for the parent element.</param>
 /// <param name="parentElement">Parent element of element to process.</param>
 /// <param name="attribute">Attribute to process.</param>
 /// <param name="contextValues">Extra information about the context in which this element is being parsed.</param>
 public override void ParseAttribute(SourceLineNumberCollection sourceLineNumbers, XmlElement parentElement, XmlAttribute attribute, Dictionary<string, string> contextValues)
 {
     switch (parentElement.LocalName)
     {
         case "Extension":
             // at the time the IsRichSavedGame extension attribute is parsed, the compiler
             // might not yet have parsed the Id attribute, so we need to get it directly
             // from the parent element and put it into the contextValues dictionary.
             string extensionId = parentElement.GetAttribute("Id");
             if (String.IsNullOrEmpty(extensionId))
             {
                 this.Core.OnMessage(WixErrors.ExpectedParentWithAttribute(sourceLineNumbers, "Extension", "IsRichSavedGame", "Id"));
             }
             else
             {
                 contextValues["ExtensionId"] = extensionId;
                 switch (attribute.LocalName)
                 {
                     case "IsRichSavedGame":
                         if (YesNoType.Yes == this.Core.GetAttributeYesNoValue(sourceLineNumbers, attribute))
                         {
                             this.ProcessIsRichSavedGameAttribute(sourceLineNumbers, contextValues);
                         }
                         break;
                     default:
                         this.Core.UnexpectedAttribute(sourceLineNumbers, attribute);
                         break;
                 }
             }
             break;
         default:
             this.Core.UnexpectedElement(parentElement, parentElement);
             break;
     }
 }

 private static DateTime GetModifiedDateTime(DateTime dateTime, XmlAttribute attr, int value)
 {
     switch (attr.Name.ToLower(CultureInfo.InvariantCulture))
     {
         case "year":
         case "addyear":
             dateTime = dateTime.AddYears(value);
             break;
         case "month":
         case "addmonth":
             dateTime = dateTime.AddMonths(value);
             break;
         case "week":
         case "addweek":
             dateTime = dateTime.AddDays(value * 7);
             break;
         case "day":
         case "adday":
             dateTime = dateTime.AddDays(value);
             break;
         case "hour":
         case "addhour":
             dateTime = dateTime.AddHours(value);
             break;
         case "min":
         case "addmin":
             dateTime = dateTime.AddMinutes(value);
             break;
         case "sec":
         case "addsec":
             dateTime = dateTime.AddSeconds(value);
             break;
     }
     return dateTime;
 }

		internal XmlAttributeEventArgs(XmlAttribute attr, int lineNum, int linePos, object source)
		{
			this.attr		= attr;
			this.lineNumber = lineNum;
			this.linePosition = linePos;
			this.obj		= source;
		}

 // Methods
 private static string FilterNull(XmlAttribute strValue)
 {
     if (strValue != null)
     {
         return strValue.Value.ToString();
     }
     return "";
 }

 internal XmlAttributeEventArgs(XmlAttribute attr, int lineNumber, int linePosition, object o, string qnames)
 {
     this.attr = attr;
     this.o = o;
     this.qnames = qnames;
     this.lineNumber = lineNumber;
     this.linePosition = linePosition;
 }

        void AddXmlNode(XmlNode node, XmlAttribute attribute)
        {
            if (mResourceNodes.ContainsKey(attribute.Value.ToString()))
                return;

            mResourceNodes.Add(attribute.Value.ToString(), node);
            mResourceNameList.Add(attribute.Value.ToString());
        }

 static bool AreEqual(XmlAttribute lhs, XmlAttribute rhs)
 {
     if(lhs.Name != rhs.Name)
         return false;
     if (lhs.Value != rhs.Value)
         return false;
     return true;
 }

 XmlAttribute attrXmlNS;  //Used for "Xml" namespace attribute which should be present on all nodes.
 internal DocumentXPathNavigator( XmlNode node ) {
     Debug.Assert( ( (int)(node.XPNodeType) ) != -1 );
     _curNode = node;
     _doc = (_curNode.NodeType == XmlNodeType.Document) ? (XmlDocument)_curNode : _curNode.OwnerDocument;
     _attrInd = -1;
     attrXmlNS = _doc.CreateAttribute( "xmlns", "xml", XmlDocument.strReservedXmlns );
     attrXmlNS.Value = "http://www.w3.org/XML/1998/namespace";
 }

 private static string GetRelativePath(XmlAttribute attribute)
 {
     var path = attribute.Value;
     if (!path.Contains(Constants.BACKSLASH)){
         return null;
     }
     var lastSlash = path.LastIndexOf(Constants.BACKSLASH, StringComparison.Ordinal);
     return path.Substring(0, lastSlash + 1);
 }

 void IHasAttribute.InitAtrribute(XmlAttribute Attr)
 {
     if(ID == "mesh2-geometry-position-array")
     {
     }
     if(Attr.Name == "count")
         Count	= uint.Parse(Attr.Value);
     else InitAtrrib(Attr);
 }