Пример #1
0
	public void DumpReader (XmlReader xr, bool attValue)
	{
		Console.WriteLine ("NodeType: " + xr.NodeType);
		Console.WriteLine ("Prefix: " + xr.Prefix);
		Console.WriteLine ("Name: " + xr.Name);
		Console.WriteLine ("LocalName: " + xr.LocalName);
		Console.WriteLine ("NamespaceURI: " + xr.NamespaceURI);
		Console.WriteLine ("Value: " + xr.Value);
		Console.WriteLine ("Depth: " + xr.Depth);
		Console.WriteLine ("IsEmptyElement: " + xr.IsEmptyElement);

		if (xr.NodeType == XmlNodeType.Attribute) {
			Console.WriteLine ("Attribute Values::::");
			while (xr.ReadAttributeValue ())
				DumpReader (xr, true);
			Console.WriteLine (":::Attribute Values End");
		} else if (!attValue) {
			Console.WriteLine ("Attributes::::");
			Console.Write (xr.AttributeCount);
			if (xr.MoveToFirstAttribute ()) {
				do {
					DumpReader (xr, false);
				} while (xr.MoveToNextAttribute ());
				xr.MoveToElement ();
			}
			Console.WriteLine (":::Attributes End");
		}
	}
    // Use this for initialization
    void Start()
    {
        string last_element = "";
        int counter = 1;

        textAsset = (TextAsset) Resources.Load("XMLs/tea_dialog");
        reader = XmlReader.Create(new StringReader(textAsset.text));

        //pull in the animation names from the xml file
        while (reader.Read ()) {

            if(reader.NodeType == XmlNodeType.Element){

                while(reader.MoveToNextAttribute())
                {
                    if(reader.Name == "id")
                    {
                        //print (counter + " : " + reader.Value);
                        animIndices.Add (counter, reader.Value);
                        counter += 1;
                    }
                }

            }
        }

        //print out hash table, for testing purposes
        //printHashTable ();
    }
        void IFlickrParsable.Load(XmlReader reader)
        {
            if (reader.LocalName != "photoset")
            {
                UtilityMethods.CheckParsingException(reader);
            }

            while (reader.MoveToNextAttribute())
            {
                switch (reader.LocalName)
                {
                case "id":
                    PhotosetId = reader.Value;
                    break;

                case "primary":
                    PrimaryPhotoId = reader.Value;
                    break;

                case "owner":
                    OwnerId = reader.Value;
                    break;

                case "ownername":
                    OwnerName = reader.Value;
                    break;

                case "page":
                    Page = int.Parse(reader.Value, NumberFormatInfo.InvariantInfo);
                    break;

                case "total":
                    Total = int.Parse(reader.Value, NumberFormatInfo.InvariantInfo);
                    break;

                case "pages":
                    Pages = int.Parse(reader.Value, NumberFormatInfo.InvariantInfo);
                    break;

                case "perpage":
                case "per_page":
                    PerPage = int.Parse(reader.Value, NumberFormatInfo.InvariantInfo);
                    break;

                case "title":
                    Title = reader.Value;
                    break;

                default:
                    UtilityMethods.CheckParsingException(reader);
                    break;
                }
            }

            reader.Read();

            while (reader.LocalName == "photo")
            {
                var photo = new Photo();
                ((IFlickrParsable)photo).Load(reader);
                if (String.IsNullOrEmpty(photo.UserId))
                {
                    photo.UserId = OwnerId;
                }
                Add(photo);
            }

            reader.Skip();
        }
Пример #4
0
        internal object LoadData(XmlReader reader, Type type, object obj)
        {
            Dictionary <string, string> metadata = null;
            int depth = reader.Depth;

            while (reader.Read())
            {
                if ((reader.NodeType == XmlNodeType.EndElement) && (reader.Depth <= depth))
                {
                    break;
                }

                if (reader.NodeType != XmlNodeType.Element)
                {
                    continue;
                }

                if (reader.Name == "Meta")
                {
                    if (metadata == null)
                    {
                        metadata = new Dictionary <string, string>();
                    }

                    reader.MoveToFirstAttribute();
                    do
                    {
                        metadata.Add(reader.Name, reader.ReadContentAsString());
                    } while (reader.MoveToNextAttribute());
                }

                if (reader.IsEmptyElement)
                {
                    continue;
                }

                Destroyable dObj = obj as Destroyable;

                // A Type object has no reasonable default value.
                if ((type != typeof(Type)) && (obj == null || (dObj != null && dObj.IsDestroyed)))
                {
                    object tag  = obj is Tagged ? ((Tagged)obj).Tag : null;
                    string stag = tag as string;

                    if (!TryCreateObject(type, stag, out obj))
                    {
                        throw new NullReferenceException("Object of type " + type.Name + " must be initialized before it can be loaded since there is no factory method or default constructor for it.");
                    }
                }

                if (reader.Name == "Field" || reader.Name == "Property")
                {
                    string mName = reader.GetAttribute("Name");
                    Type   mType = TypeHelper.Parse(reader.GetAttribute("Type"));

                    if (reader.Name == "Property")
                    {
                        PropertyInfo propInfo = type.GetProperty(mName, BindingFlags.GetProperty | AllOfInstance);
                        if (propInfo == null)
                        {
                            throw new ArgumentException(type.Name + " does not contain property " + mName);
                        }
                        object mValue = propInfo.GetValue(obj, null);
                        mValue = LoadData(reader, mType, mValue);
                        propInfo.SetValue(obj, mValue, null);
                    }
                    else
                    {
                        FieldInfo fieldInfo = type.GetField(mName, BindingFlags.GetField | AllOfInstance);
                        if (fieldInfo == null)
                        {
                            throw new ArgumentException(type.Name + " does not contain field " + mName);
                        }
                        object mValue = fieldInfo.GetValue(obj);
                        mValue = LoadData(reader, mType, mValue);
                        fieldInfo.SetValue(obj, mValue);
                    }
                }
                else if (reader.Name == "SerializedObject")
                {
                    // Used for legacy support only

                    reader.Read();
                    object objValue = null;

                    using (MemoryStream dataStream = new MemoryStream(Encoding.Unicode.GetBytes(reader.Value)))
                    {
                        XmlSerializer serializer = new XmlSerializer(type);
                        objValue = serializer.Deserialize(dataStream);
                    }

                    while (!reader.EOF && reader.NodeType != XmlNodeType.EndElement)
                    {
                        reader.Read();
                    }

                    obj = objValue;
                }
                else if (reader.Name == "Value")
                {
                    reader.Read();

                    if (type.IsEnum)
                    {
                        obj = Enum.Parse(type, reader.Value, false);
                    }
                    else
                    {
                        obj = GenParse(type, reader.Value);
                    }

                    while (!reader.EOF && reader.NodeType != XmlNodeType.EndElement)
                    {
                        reader.Read();
                    }
                }
                else if (reader.Name == "Array")
                {
                    Type mType = TypeHelper.Parse(reader.GetAttribute("Type"));
                    obj = LoadArray(reader, mType, obj);
                }
                else if (reader.Name == "List")
                {
                    Type mType     = TypeHelper.Parse(reader.GetAttribute("Type"));
                    int  itemCount = int.Parse(reader.GetAttribute("Count"));
                    obj = LoadList(reader, mType, itemCount, obj);
                }
            }

            if (metadata != null)
            {
                foreach (KeyValuePair <string, string> entry in metadata)
                {
                    applyMetadata(type, obj, entry.Key, entry.Value);
                }
            }

            return(obj);
        }
Пример #5
0
        protected override object CreateInstance(WorkflowMarkupSerializationManager serializationManager, Type type)
        {
            Activity activity3;

            if (serializationManager == null)
            {
                throw new ArgumentNullException("serializationManager");
            }
            if (type == null)
            {
                throw new ArgumentNullException("type");
            }
            object        obj2    = null;
            IDesignerHost service = serializationManager.GetService(typeof(IDesignerHost)) as IDesignerHost;
            XmlReader     reader  = serializationManager.WorkflowMarkupStack[typeof(XmlReader)] as XmlReader;

            if ((service == null) || (reader == null))
            {
                return(obj2);
            }
            string str = string.Empty;

            while (reader.MoveToNextAttribute() && !reader.LocalName.Equals("Name", StringComparison.Ordinal))
            {
            }
            if (reader.LocalName.Equals("Name", StringComparison.Ordinal) && reader.ReadAttributeValue())
            {
                str = reader.Value;
            }
            reader.MoveToElement();
            if (string.IsNullOrEmpty(str))
            {
                serializationManager.ReportError(SR.GetString("Error_LayoutSerializationAssociatedActivityNotFound", new object[] { reader.LocalName, "Name" }));
                return(obj2);
            }
            CompositeActivityDesigner designer = serializationManager.Context[typeof(CompositeActivityDesigner)] as CompositeActivityDesigner;

            if (designer != null)
            {
                CompositeActivity activity2 = designer.Activity as CompositeActivity;
                if (activity2 == null)
                {
                    goto Label_01D0;
                }
                activity3 = null;
                foreach (Activity activity4 in activity2.Activities)
                {
                    if (str.Equals(activity4.Name, StringComparison.Ordinal))
                    {
                        activity3 = activity4;
                        break;
                    }
                }
            }
            else
            {
                Activity rootComponent = service.RootComponent as Activity;
                if ((rootComponent != null) && !str.Equals(rootComponent.Name, StringComparison.Ordinal))
                {
                    foreach (IComponent component in service.Container.Components)
                    {
                        rootComponent = component as Activity;
                        if ((rootComponent != null) && str.Equals(rootComponent.Name, StringComparison.Ordinal))
                        {
                            break;
                        }
                    }
                }
                if (rootComponent != null)
                {
                    obj2 = service.GetDesigner(rootComponent);
                }
                goto Label_01D0;
            }
            if (activity3 != null)
            {
                obj2 = service.GetDesigner(activity3);
            }
Label_01D0:
            if (obj2 == null)
            {
                serializationManager.ReportError(SR.GetString("Error_LayoutSerializationActivityNotFound", new object[] { reader.LocalName, str, "Name" }));
            }
            return(obj2);
        }
Пример #6
0
        static void Main(string[] args)
        {
            XmlReaderSettings readerSettings = new XmlReaderSettings();

            readerSettings.IgnoreWhitespace = true;
            readerSettings.IgnoreComments   = true;
            readerSettings.ValidationType   = ValidationType.Schema;
            readerSettings.Schemas.Add(null, @"..\..\Personen.xsd");
            readerSettings.ValidationEventHandler += ValidationCallback;

            XmlReader reader = XmlReader.Create(@"..\..\Personen.xml", readerSettings);

            try{
                while (reader.Read())
                {
                    switch (reader.NodeType)
                    {
                    case XmlNodeType.XmlDeclaration:
                        Console.WriteLine("{0,-20}<{1}>", "DEKLARATION", reader.Value);
                        break;

                    case XmlNodeType.CDATA:
                        Console.WriteLine("{0,-20}{1}", "CDATA", reader.Value);
                        break;

                    case XmlNodeType.Whitespace:
                        Console.WriteLine("{0,-20}", "WHITESPACE");
                        break;

                    case XmlNodeType.Comment:
                        Console.WriteLine("{0,-20}<!--{1}-->", "COMMENT", reader.Value);
                        break;

                    case XmlNodeType.Element:
                        if (reader.IsEmptyElement)
                        {
                            Console.WriteLine("{0,-20}<{1} />", "EMPTY_ELEMENT", reader.Name);
                        }
                        else
                        {
                            Console.WriteLine("{0,-20}<{1}>", "ELEMENT", reader.Name);
                            // Prüfen, ob der Knoten Attribute hat
                            if (reader.HasAttributes)
                            {
                                // Durch die Attribute navigieren
                                while (reader.MoveToNextAttribute())
                                {
                                    Console.WriteLine("{0,-20}{1}", "ATTRIBUT", reader.Name + "=" + reader.Value);
                                }
                            }
                        }
                        break;

                    case XmlNodeType.EndElement:
                        Console.WriteLine("{0,-20}</{1}>", "END_ELEMENT", reader.Name);
                        break;

                    case XmlNodeType.Text:
                        Console.WriteLine("{0,-20}{1}", "TEXT", reader.Value);
                        break;
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("Validierung fehlgeschlagen.\n{0}", ex.Message);
            }
            reader.Close();
            Console.ReadLine();
        }
Пример #7
0
 public bool ParseReaderNode()
 {
     if (reader.Depth > markupDepth)
     {
         if (processMarkup)
         {
             ProcessAppInfoDocMarkup(false);
         }
         return(true);
     }
     else if (reader.NodeType == XmlNodeType.Element)
     {
         if (builder.ProcessElement(reader.Prefix, reader.LocalName, reader.NamespaceURI))
         {
             namespaceManager.PushScope();
             if (reader.MoveToFirstAttribute())
             {
                 do
                 {
                     builder.ProcessAttribute(reader.Prefix, reader.LocalName, reader.NamespaceURI, reader.Value);
                     if (Ref.Equal(reader.NamespaceURI, schemaNames.NsXmlNs) && isProcessNamespaces)
                     {
                         namespaceManager.AddNamespace(reader.Prefix.Length == 0 ? string.Empty : reader.LocalName, reader.Value);
                     }
                 }while (reader.MoveToNextAttribute());
                 reader.MoveToElement(); // get back to the element
             }
             builder.StartChildren();
             if (reader.IsEmptyElement)
             {
                 namespaceManager.PopScope();
                 builder.EndChildren();
                 if (reader.Depth == schemaXmlDepth)
                 {
                     return(false); // done
                 }
             }
             else if (!builder.IsContentParsed())   //AppInfo and Documentation
             {
                 markupDepth   = reader.Depth;
                 processMarkup = true;
                 if (annotationNSManager == null)
                 {
                     annotationNSManager = new XmlNamespaceManager(nameTable);
                     xmlns = nameTable.Add("xmlns");
                 }
                 ProcessAppInfoDocMarkup(true);
             }
         }
         else if (!reader.IsEmptyElement)   //UnsupportedElement in that context
         {
             markupDepth   = reader.Depth;
             processMarkup = false; //Hack to not process unsupported elements
         }
     }
     else if (reader.NodeType == XmlNodeType.Text)   //Check for whitespace
     {
         if (!xmlCharType.IsOnlyWhitespace(reader.Value))
         {
             builder.ProcessCData(reader.Value);
         }
     }
     else if (reader.NodeType == XmlNodeType.EntityReference ||
              reader.NodeType == XmlNodeType.SignificantWhitespace ||
              reader.NodeType == XmlNodeType.CDATA)
     {
         builder.ProcessCData(reader.Value);
     }
     else if (reader.NodeType == XmlNodeType.EndElement)
     {
         if (reader.Depth == markupDepth)
         {
             if (processMarkup)
             {
                 Debug.Assert(parentNode != null);
                 XmlNodeList list   = parentNode.ChildNodes;
                 XmlNode[]   markup = new XmlNode[list.Count];
                 for (int i = 0; i < list.Count; i++)
                 {
                     markup[i] = list[i];
                 }
                 builder.ProcessMarkup(markup);
                 namespaceManager.PopScope();
                 builder.EndChildren();
             }
             markupDepth = int.MaxValue;
         }
         else
         {
             namespaceManager.PopScope();
             builder.EndChildren();
         }
         if (reader.Depth == schemaXmlDepth)
         {
             return(false); // done
         }
     }
     return(true);
 }
Пример #8
0
    // Read and extract into InterfaceRight class each attribut of node name "group"
    InterfaceElement check_attribute_group(XmlReader xml_reader)
    {
        InterfaceElement s_InterfaceElement = new InterfaceElement();
        s_InterfaceElement.mse_type = 0;
        s_InterfaceElement.b_toggle_type = false;
        s_InterfaceElement.s_content = "undefined";
        s_InterfaceElement.s_text_area = "Choose a title";

        if (xml_reader.HasAttributes)
        {
            while (xml_reader.MoveToNextAttribute() != false)
            {
                bool valide_type = true;
                string save_type = "";
                string save_readstring = "";
                string save_content = "";

                // if type exist, else, a button will be created
                if ((save_type = xml_reader.GetAttribute("type")) != null)
                {
                    if (Enum.IsDefined(typeof(me_button_type),save_type) == true)
                        s_InterfaceElement.mse_type = (me_button_type)Enum.Parse(typeof(me_button_type), save_type);
                    else
                        valide_type = false;
                }

                // if content as attribute or string exist, else, "undefined" has been saved
                if ((save_content = xml_reader.GetAttribute("content")) != null || (save_readstring = xml_reader.ReadString()) != null)
                {
                    s_InterfaceElement.s_content = save_content != null ? save_content : save_readstring;
                    if (valide_type == false)
                        s_InterfaceElement.s_content += " (Coming Soon)";
                }
            }
        }
        return s_InterfaceElement;
    }
Пример #9
0
        private void ProcessDisplayFolder(XmlReader rdr, ADOTabularTable table, IADOTabularFolderReference parent)
        {
            var    folderReference = "";
            string folderCaption   = null;
            string objRef          = "";

            while (!(rdr.NodeType == XmlNodeType.EndElement &&
                     rdr.LocalName == "DisplayFolder"))
            {
                if (rdr.NodeType == XmlNodeType.Element &&
                    rdr.LocalName == "DisplayFolder")
                {
                    while (rdr.MoveToNextAttribute())
                    {
                        switch (rdr.LocalName)
                        {
                        case "Name":
                            folderReference = rdr.Value;
                            break;

                        case "Caption":
                            folderCaption = rdr.Value;
                            break;
                        }
                    }
                    // create folder and add to parent's folders
                    IADOTabularFolderReference folder = new ADOTabularDisplayFolder(folderCaption, folderReference);
                    parent.FolderItems.Add(folder);

                    rdr.ReadToNextElement();

                    // recurse down to child items
                    ProcessDisplayFolder(rdr, table, folder);
                    rdr.Read();
                    //rdr.ReadToNextElement(); // read the end element
                }

                if ((rdr.NodeType == XmlNodeType.Element) &&
                    (rdr.LocalName == "PropertyRef"))
                {
                    while (rdr.MoveToNextAttribute())
                    {
                        switch (rdr.LocalName)
                        {
                        case "Name":
                            objRef = rdr.Value;
                            break;
                        }
                    }

                    // create reference object
                    IADOTabularObjectReference reference = new ADOTabularObjectReference("", objRef);
                    parent.FolderItems.Add(reference);
                    var column = table.Columns.GetByPropertyRef(objRef);
                    if (column != null)
                    {
                        column.IsInDisplayFolder = true;
                    }
                    objRef = "";

                    rdr.Read();
                }

                if ((rdr.NodeType != XmlNodeType.Element && rdr.NodeType != XmlNodeType.EndElement) && (rdr.LocalName != "DisplayFolder" && rdr.LocalName != "PropertyRef" && rdr.LocalName != "DisplaFolders"))
                {
                    rdr.ReadToNextElement();
                }

                if (rdr.NodeType == XmlNodeType.EndElement && rdr.LocalName == "DisplayFolders")
                {
                    rdr.Read();
                    break;
                }

                //rdr.Read();
            }
        }
Пример #10
0
        private List <ADOTabularVariation> ProcessVariations(XmlReader rdr)
        {
            string _name    = string.Empty;
            bool   _default = false;
            string navigationPropertyRef = string.Empty;
            string defaultHierarchyRef   = string.Empty;

            List <ADOTabularVariation> _variations = new List <ADOTabularVariation>();

            while (!(rdr.NodeType == XmlNodeType.EndElement &&
                     rdr.LocalName == "Variations"))
            {
                if (rdr.NodeType == XmlNodeType.Element &&
                    rdr.LocalName == "Variation")
                {
                    while (rdr.MoveToNextAttribute())
                    {
                        switch (rdr.LocalName)
                        {
                        case "Name":
                            _name = rdr.Value;
                            break;

                        case "Default":
                            _default = bool.Parse(rdr.Value);
                            break;
                        }
                    }
                }

                if (rdr.NodeType == XmlNodeType.Element &&
                    rdr.LocalName == "NavigationPropertyRef")
                {
                    while (rdr.MoveToNextAttribute())
                    {
                        if (rdr.LocalName == "Name")
                        {
                            navigationPropertyRef = rdr.Value;
                        }
                    }
                }

                if (rdr.NodeType == XmlNodeType.Element &&
                    rdr.LocalName == "DefaultHierarchyRef")
                {
                    while (rdr.MoveToNextAttribute())
                    {
                        if (rdr.LocalName == "Name")
                        {
                            defaultHierarchyRef = rdr.Value;
                        }
                    }
                }


                if (rdr.NodeType == XmlNodeType.EndElement &&
                    rdr.LocalName == "Variation")
                {
                    _variations.Add(new ADOTabularVariation()
                    {
                        NavigationPropertyRef = navigationPropertyRef, DefaultHierarchyRef = defaultHierarchyRef, IsDefault = _default
                    });
                    _default = false;
                    navigationPropertyRef = string.Empty;
                    defaultHierarchyRef   = string.Empty;
                }
                rdr.Read();
            }
            return(_variations);
        }
Пример #11
0
        private void AddColumnsToTable(XmlReader rdr
                                       , ADOTabularTableCollection tables
                                       , string eEntityType)
        {
            var eProperty   = rdr.NameTable.Add("Property");
            var eMeasure    = rdr.NameTable.Add("Measure");
            var eSummary    = rdr.NameTable.Add("Summary");
            var eStatistics = rdr.NameTable.Add("Statistics");
            var eMinValue   = rdr.NameTable.Add("MinValue");
            var eMaxValue   = rdr.NameTable.Add("MaxValue");

            // this routine effectively processes and <EntityType> element and it's children
            string caption                         = "";
            string description                     = "";
            bool   isVisible                       = true;
            string name                            = null;
            string refName                         = "";
            string tableId                         = "";
            string dataType                        = "";
            string contents                        = "";
            string minValue                        = "";
            string maxValue                        = "";
            string formatString                    = "";
            string defaultAggregateFunction        = "";
            long   stringValueMaxLength            = 0;
            long   distinctValueCount              = 0;
            bool   nullable                        = true;
            List <ADOTabularVariation> _variations = new List <ADOTabularVariation>();

            KpiDetails kpi = new KpiDetails();

            var colType = ADOTabularObjectType.Column;

            while (!(rdr.NodeType == XmlNodeType.EndElement &&
                     rdr.LocalName == eEntityType))
            {
                if (rdr.NodeType == XmlNodeType.Element &&
                    rdr.LocalName == eEntityType)
                {
                    while (rdr.MoveToNextAttribute())
                    {
                        switch (rdr.LocalName)
                        {
                        case "Name":
                            tableId = rdr.Value;
                            break;
                        }
                    }
                }

                if (rdr.NodeType == XmlNodeType.Element &&
                    rdr.LocalName == "Hierarchy")
                {
                    ProcessHierarchy(rdr, tables.GetById(tableId), eEntityType);
                }

                if (rdr.NodeType == XmlNodeType.Element &&
                    rdr.LocalName == "DisplayFolder")
                {
                    Debug.WriteLine("FoundFolder");
                    var tbl = tables.GetById(tableId);
                    ProcessDisplayFolder(rdr, tbl, tbl);
                }

                if (rdr.NodeType == XmlNodeType.Element &&
                    rdr.LocalName == "Kpi")
                {
                    kpi = ProcessKpi(rdr, tables.GetById(tableId));
                }

                if (rdr.NodeType == XmlNodeType.Element &&
                    (rdr.LocalName == eProperty ||
                     rdr.LocalName == eMeasure ||
                     rdr.LocalName == eSummary ||
                     rdr.LocalName == eStatistics ||
                     rdr.LocalName == eMinValue ||
                     rdr.LocalName == eMaxValue))
                {
                    if (rdr.LocalName == eMeasure)
                    {
                        colType = ADOTabularObjectType.Measure;
                    }

                    if (rdr.LocalName == eSummary)
                    {
                        description = rdr.ReadElementContentAsString();
                    }

                    while (rdr.MoveToNextAttribute())
                    {
                        switch (rdr.LocalName)
                        {
                        case "Name":
                            refName = rdr.Value;
                            break;

                        case "ReferenceName":      // reference name will always come after the Name and will override it if present
                            name = rdr.Value;
                            break;

                        case "Type":
                            dataType = rdr.Value;
                            break;

                        case "Caption":
                            caption = rdr.Value;
                            break;

                        case "Contents":
                            contents = rdr.Value;
                            break;

                        case "Hidden":
                            isVisible = !bool.Parse(rdr.Value);
                            break;

                        case "Description":
                            description = rdr.Value;
                            break;

                        case "DistinctValueCount":
                            distinctValueCount = long.Parse(rdr.Value);
                            break;

                        case "StringValueMaxLength":
                            stringValueMaxLength = long.Parse(rdr.Value);
                            break;

                        case "FormatString":
                            formatString = rdr.Value;
                            break;

                        case "DefaultAggregateFunction":
                            defaultAggregateFunction = rdr.Value;
                            break;

                        case "Nullable":
                            nullable = bool.Parse(rdr.Value);
                            break;
                            // Precision Scale
                            //TODO - Add RowCount
                        }
                    }
                }

                if (rdr.NodeType == XmlNodeType.Element &&
                    rdr.LocalName == "Variations")
                {
                    _variations = ProcessVariations(rdr);
                }


                if (rdr.NodeType == XmlNodeType.EndElement &&
                    rdr.LocalName == eProperty &&
                    rdr.LocalName == "Property")
                {
                    if (caption.Length == 0)
                    {
                        caption = refName;
                    }
                    if (!string.IsNullOrWhiteSpace(caption))
                    {
                        var tab = tables.GetById(tableId);
                        if (kpi.IsBlank())
                        {
                            var col = new ADOTabularColumn(tab, refName, name, caption, description, isVisible, colType, contents);
                            col.DataType             = Type.GetType(string.Format("System.{0}", dataType));
                            col.Nullable             = nullable;
                            col.MinValue             = minValue;
                            col.MaxValue             = maxValue;
                            col.DistinctValues       = distinctValueCount;
                            col.FormatString         = formatString;
                            col.StringValueMaxLength = stringValueMaxLength;
                            col.Variations.AddRange(_variations);
                            tables.Model.AddRole(col);
                            tab.Columns.Add(col);
                            _conn.Columns.Add(col.OutputColumnName, col);
                        }
                        else
                        {
                            colType = ADOTabularObjectType.KPI;
                            var kpiCol = new ADOTabularKpi(tab, refName, name, caption, description, isVisible, colType, contents, kpi);
                            kpiCol.DataType = Type.GetType(string.Format("System.{0}", dataType));
                            tab.Columns.Add(kpiCol);
                            _conn.Columns.Add(kpiCol.OutputColumnName, kpiCol);
                        }
                    }


                    // reset temp variables
                    kpi                      = new KpiDetails();
                    refName                  = "";
                    caption                  = "";
                    name                     = null;
                    description              = "";
                    isVisible                = true;
                    contents                 = "";
                    dataType                 = "";
                    stringValueMaxLength     = -1;
                    formatString             = "";
                    defaultAggregateFunction = "";
                    nullable                 = true;
                    colType                  = ADOTabularObjectType.Column;
                    _variations              = new List <ADOTabularVariation>();
                }
                rdr.Read();
            }

            //TODO - link up back reference to backing measures for KPIs
        }
Пример #12
0
	/// <summary>
	/// Find all links.
	/// </summary>
	private IEnumerable<string> findAllLinks(
		XmlReader xml,
		string baseUrl )
	{
		var links = new List<string>();

		while ( xml.Read() )
		{
			switch ( xml.NodeType )
			{
				// Added 2006-03-27: Inside comments, too.
				case XmlNodeType.Comment:
					XmlReader childXml = getDocReader( xml.Value, baseUrl );

					IEnumerable<string> childLinks = findAllLinks( childXml, baseUrl );
					links.AddRange( childLinks );
					break;

				// A node element.
				case XmlNodeType.Element:
					string[] linkAttributeNames;
					// If this is a link element, store the URLs to modify.
					if ( isLinkElement( xml.Name, out linkAttributeNames ) )
					{
						while ( xml.MoveToNextAttribute() )
						{
							checkAddStyleAttributeLinks(
								xml.Name,
								xml.Value,
								links );

// ReSharper disable LoopCanBeConvertedToQuery
							foreach ( string a in linkAttributeNames )
// ReSharper restore LoopCanBeConvertedToQuery
							{
								if ( a.ToLower() == xml.Name.ToLower() )
								{
									string linkUrl = xml.Value;

									if ( !isAbsoluteUrl( linkUrl ) )
									{
										links.Add( linkUrl );
									}
								}
							}
						}
					}
					else
					{
						// Also, look for style attributes.
						while ( xml.MoveToNextAttribute() )
						{
							checkAddStyleAttributeLinks(
								xml.Name,
								xml.Value,
								links );
						}
					}
					break;
			}
		}

		return links.ToArray();
	}
Пример #13
0
  } //ReadTransformWrite()

  /// <summary>
  /// Output the tranformed XML in annotated form to the console.
  /// Calls the Output method.
  /// </summary>
  /// <param name="reader"></param>
  private static void OutputXml (XmlReader reader)
  {
    while (reader.Read())
    {
      switch (reader.NodeType)
      {
        case XmlNodeType.ProcessingInstruction:
          Output(reader, "ProcessingInstruction");
          break;

        case XmlNodeType.DocumentType:
          Output(reader, "DocumentType");
          break;

        case XmlNodeType.Document:
          Output(reader, "Document");
          break;

        case XmlNodeType.Comment:
          Output(reader, "Comment");
          break;

        case XmlNodeType.Element:
          Output(reader, "Element");
          while(reader.MoveToNextAttribute())
          {
            Output(reader, "Attribute");
          } //while
          break;

        case XmlNodeType.Text:
          Boolean flag = false;
          // Do not display whitespace text nodes
          for (int i=0; i < reader.Value.Length; i++)
          {
            if (!System.Char.IsWhiteSpace(reader.Value[i]))
              flag = true;
          } //for
          if(flag)
            Output (reader, "Text");
          break;
      } //switch
    } //while
    Console.WriteLine();
  } //OutputXML()
 /* Method to extract the client specific parts of the config file */
 private bool ExtractClientConfig(XmlReader reader)
 {
     try {
         while (reader.Read()) {
             if (reader.IsStartElement()) {
                 if (reader.Name == "client") {
                     client_config.Add(new ClientConfig());
                     while (reader.MoveToNextAttribute()) {
                         if (reader.Name == "name")
                             client_config.Last().name.Add("short_name", reader.Value);
                         else if (reader.Name == "lname")
                             client_config.Last().name.Add("full_name", reader.Value);
                         else
                             Console.WriteLine("Unknown report configuration attribute: " + reader.Name);
                     }
                 }
                 else if (reader.Name == "project")
                     client_config.Last().projects.Add(reader.ReadString());
                 else if (reader.Name == "priority")
                     client_config.Last().priority.Add(reader.ReadString());
                 else if (reader.Name == "email")
                     client_config.Last().email.Add(reader.ReadString());
             }
         }
         return true;
     }
     catch (Exception ex) {
         Console.WriteLine("Exception when extracting client data from config XML: " + ex.Message);
         return false;
     }
 }
Пример #15
0
        /// <summary>
        /// Protected method that does the actual initialization of the Photo instance. Should be called by subclasses of the Photo class.
        /// </summary>
        /// <param name="reader">The reader containing the XML to be parsed.</param>
        /// <param name="allowExtraAtrributes">Wheither to allow unknown extra attributes.
        /// In debug builds will throw an exception if this parameter is false and an unknown attribute is found.</param>
        protected void Load(XmlReader reader, bool allowExtraAtrributes)
        {
            if (reader.LocalName != "photo" && reader.LocalName != "primary_photo_extras")
            {
                UtilityMethods.CheckParsingException(reader);
            }

            while (reader.MoveToNextAttribute())
            {
                switch (reader.LocalName)
                {
                case "id":
                    PhotoId = reader.Value;
                    if (string.IsNullOrEmpty(reader.Value))
                    {
                        reader.Skip();
                        return;
                    }
                    break;

                case "owner":
                    UserId = reader.Value;
                    break;

                case "secret":
                    Secret = reader.Value;
                    break;

                case "server":
                    Server = reader.Value;
                    break;

                case "farm":
                    Farm = reader.Value;
                    break;

                case "title":
                    Title = reader.Value;
                    break;

                case "ispublic":
                    IsPublic = reader.Value == "1";
                    break;

                case "isfamily":
                    IsFamily = reader.Value == "1";
                    break;

                case "isfriend":
                    IsFriend = reader.Value == "1";
                    break;

                case "tags":
                    foreach (string tag in reader.Value.Split(' '))
                    {
                        Tags.Add(tag);
                    }
                    break;

                case "datetaken":
                case "date-taken":
                case "date_taken":
                    // For example : 2007-11-04 08:55:18
                    DateTaken = UtilityMethods.ParseDateWithGranularity(reader.Value);
                    break;

                case "datetakengranularity":
                    break;

                case "datetakenunknown":
                    DateTakenUnknown = reader.Value == "1";
                    break;

                case "dateupload":
                    DateUploaded = UtilityMethods.UnixTimestampToDate(reader.Value);
                    break;

                case "license":
                    License = (LicenseType)int.Parse(reader.Value, System.Globalization.CultureInfo.InvariantCulture);
                    break;

                case "ownername":
                    OwnerName = reader.Value;
                    break;

                case "lastupdate":
                    LastUpdated = UtilityMethods.UnixTimestampToDate(reader.Value);
                    break;

                case "originalformat":
                    OriginalFormat = reader.Value;
                    break;

                case "originalsecret":
                    OriginalSecret = reader.Value;
                    break;

                case "place_id":
                    PlaceId = reader.Value;
                    break;

                case "woeid":
                    WoeId = reader.Value;
                    break;

                case "accuracy":
                    Accuracy = (GeoAccuracy)reader.ReadContentAsInt();
                    break;

                case "latitude":
                    Latitude = reader.ReadContentAsDouble();
                    break;

                case "longitude":
                    Longitude = reader.ReadContentAsDouble();
                    break;

                case "machine_tags":
                    MachineTags = reader.Value;
                    break;

                case "o_width":
                    OriginalWidth = int.Parse(reader.Value, System.Globalization.CultureInfo.InvariantCulture);
                    break;

                case "o_height":
                    OriginalHeight = int.Parse(reader.Value, System.Globalization.CultureInfo.InvariantCulture);
                    break;

                case "views":
                    Views = int.Parse(reader.Value, System.Globalization.CultureInfo.InvariantCulture);
                    break;

                case "media":
                    Media = reader.Value;
                    break;

                case "media_status":
                    MediaStatus = reader.Value;
                    break;

                case "iconserver":
                    IconServer = reader.Value;
                    break;

                case "iconfarm":
                    IconFarm = reader.Value;
                    break;

                case "username":
                    OwnerName = reader.Value;
                    break;

                case "isprimary":
                case "is_primary":
                    break;

                case "pathalias":
                case "path_alias":
                    PathAlias = reader.Value;
                    break;

                case "url_sq":
                    urlSquare = reader.Value;
                    break;

                case "width_sq":
                    SquareThumbnailWidth = reader.ReadContentAsInt();
                    break;

                case "height_sq":
                    SquareThumbnailHeight = reader.ReadContentAsInt();
                    break;

                case "url_t":
                    urlThumbnail = reader.Value;
                    break;

                case "width_t":
                    ThumbnailWidth = reader.ReadContentAsInt();
                    break;

                case "height_t":
                    ThumbnailHeight = reader.ReadContentAsInt();
                    break;

                case "url_q":
                    urlLargeSquare = reader.Value;
                    break;

                case "width_q":
                    LargeSquareThumbnailWidth = reader.ReadContentAsInt();
                    break;

                case "height_q":
                    LargeSquareThumbnailHeight = reader.ReadContentAsInt();
                    break;

                case "url_n":
                    urlSmall320 = reader.Value;
                    break;

                case "width_n":
                    Small320Width = reader.ReadContentAsInt();
                    break;

                case "height_n":
                    Small320Height = reader.ReadContentAsInt();
                    break;

                case "url_s":
                    urlSmall = reader.Value;
                    break;

                case "width_s":
                    SmallWidth = reader.ReadContentAsInt();
                    break;

                case "height_s":
                    SmallHeight = reader.ReadContentAsInt();
                    break;

                case "url_m":
                    urlMedium = reader.Value;
                    break;

                case "width_m":
                    MediumWidth = reader.ReadContentAsInt();
                    break;

                case "height_m":
                    MediumHeight = reader.ReadContentAsInt();
                    break;

                case "url_c":
                    urlMedium800 = reader.Value;
                    break;

                case "width_c":
                    Medium800Width = reader.ReadContentAsInt();
                    break;

                case "height_c":
                    Medium800Height = reader.ReadContentAsInt();
                    break;

                case "url_l":
                    urlLarge = reader.Value;
                    break;

                case "width_l":
                    LargeWidth = reader.ReadContentAsInt();
                    break;

                case "height_l":
                    LargeHeight = reader.ReadContentAsInt();
                    break;

                case "url_z":
                    urlMedium640 = reader.Value;
                    break;

                case "width_z":
                    Medium640Width = reader.ReadContentAsInt();
                    break;

                case "height_z":
                    Medium640Height = reader.ReadContentAsInt();
                    break;

                case "url_o":
                    urlOriginal = reader.Value;
                    break;

                case "width_o":
                    OriginalWidth = reader.ReadContentAsInt();
                    break;

                case "height_o":
                    OriginalHeight = reader.ReadContentAsInt();
                    break;

                case "url_h":
                    Large1600Url = reader.Value;
                    break;

                case "width_h":
                    Large1600Width = reader.ReadContentAsInt();
                    break;

                case "height_h":
                    Large1600Height = reader.ReadContentAsInt();
                    break;

                case "url_k":
                    Large2048Url = reader.Value;
                    break;

                case "width_k":
                    Large2048Width = reader.ReadContentAsInt();
                    break;

                case "height_k":
                    Large2048Height = reader.ReadContentAsInt();
                    break;

                case "dateadded":
                    DateAddedToGroup = UtilityMethods.UnixTimestampToDate(reader.Value);
                    break;

                case "date_faved":
                    DateFavorited = UtilityMethods.UnixTimestampToDate(reader.Value);
                    break;

                case "has_comment":     // Gallery photos return this, but we ignore it and set GalleryPhoto.Comment instead.
                    break;

                case "can_comment":
                    CanComment = reader.Value == "1";
                    break;

                case "can_addmeta":
                    CanAddMeta = reader.Value == "1";
                    break;

                case "can_blog":
                    CanBlog = reader.Value == "1";
                    break;

                case "can_print":
                    CanPrint = reader.Value == "1";
                    break;

                case "can_download":
                    CanDownload = reader.Value == "1";
                    break;

                case "can_share":
                    CanShare = reader.Value == "1";
                    break;

                case "geo_is_family":
                    if (GeoPermissions == null)
                    {
                        GeoPermissions         = new GeoPermissions();
                        GeoPermissions.PhotoId = PhotoId;
                    }
                    GeoPermissions.IsFamily = reader.Value == "1";
                    break;

                case "geo_is_friend":
                    if (GeoPermissions == null)
                    {
                        GeoPermissions         = new GeoPermissions();
                        GeoPermissions.PhotoId = PhotoId;
                    }
                    GeoPermissions.IsFriend = reader.Value == "1";
                    break;

                case "geo_is_public":
                    if (GeoPermissions == null)
                    {
                        GeoPermissions         = new GeoPermissions();
                        GeoPermissions.PhotoId = PhotoId;
                    }
                    GeoPermissions.IsPublic = reader.Value == "1";
                    break;

                case "geo_is_contact":
                    if (GeoPermissions == null)
                    {
                        GeoPermissions         = new GeoPermissions();
                        GeoPermissions.PhotoId = PhotoId;
                    }
                    GeoPermissions.IsContact = reader.Value == "1";
                    break;

                case "context":
                    GeoContext = (GeoContext)reader.ReadContentAsInt();
                    break;

                case "rotation":
                    Rotation = reader.ReadContentAsInt();
                    break;

                case "count_faves":
                    CountFaves = reader.ReadContentAsInt();
                    break;

                case "count_comments":
                    CountComments = reader.ReadContentAsInt();
                    break;

                default:
                    if (!allowExtraAtrributes)
                    {
                        UtilityMethods.CheckParsingException(reader);
                    }
                    break;
                }
            }

            reader.Read();

            if (reader.LocalName == "description")
            {
                Description = reader.ReadElementContentAsString();
            }
        }
Пример #16
0
        /// <summary>
        /// Processes an XmlReader and builds up the output object.
        /// </summary>
        /// <param name="reader">Reader to get data from.</param>
        /// <param name="suppressVersionCheck">Suppresses wix.dll version mismatch check.</param>
        /// <returns>The Output represented by the Xml.</returns>
        internal static Output Read(XmlReader reader, bool suppressVersionCheck)
        {
            if (!reader.LocalName.Equals("wixOutput"))
            {
                throw new XmlException();
            }

            bool        empty       = reader.IsEmptyElement;
            Output      output      = new Output(SourceLineNumber.CreateFromUri(reader.BaseURI));
            SectionType sectionType = SectionType.Unknown;
            Version     version     = null;

            while (reader.MoveToNextAttribute())
            {
                switch (reader.LocalName)
                {
                case "codepage":
                    output.Codepage = Convert.ToInt32(reader.Value, CultureInfo.InvariantCulture.NumberFormat);
                    break;

                case "type":
                    switch (reader.Value)
                    {
                    case "Bundle":
                        output.Type = OutputType.Bundle;
                        sectionType = SectionType.Bundle;
                        break;

                    case "Module":
                        output.Type = OutputType.Module;
                        sectionType = SectionType.Module;
                        break;

                    case "Patch":
                        output.Type = OutputType.Patch;
                        break;

                    case "PatchCreation":
                        output.Type = OutputType.PatchCreation;
                        sectionType = SectionType.PatchCreation;
                        break;

                    case "Product":
                        output.Type = OutputType.Product;
                        sectionType = SectionType.Product;
                        break;

                    case "Transform":
                        output.Type = OutputType.Transform;
                        break;

                    default:
                        throw new XmlException();
                    }
                    break;

                case "version":
                    version = new Version(reader.Value);
                    break;
                }
            }

            if (!suppressVersionCheck && null != version && !Output.CurrentVersion.Equals(version))
            {
                throw new WixException(WixDataErrors.VersionMismatch(SourceLineNumber.CreateFromUri(reader.BaseURI), "wixOutput", version.ToString(), Output.CurrentVersion.ToString()));
            }

            // create a section for all the rows to belong to
            output.entrySection = new Section(null, sectionType, output.Codepage);

            // loop through the rest of the xml building up the Output object
            TableDefinitionCollection tableDefinitions = null;
            List <Table> tables = new List <Table>();

            if (!empty)
            {
                bool done = false;

                // loop through all the fields in a row
                while (!done && reader.Read())
                {
                    switch (reader.NodeType)
                    {
                    case XmlNodeType.Element:
                        switch (reader.LocalName)
                        {
                        case "subStorage":
                            output.SubStorages.Add(SubStorage.Read(reader));
                            break;

                        case "table":
                            if (null == tableDefinitions)
                            {
                                throw new XmlException();
                            }
                            tables.Add(Table.Read(reader, output.entrySection, tableDefinitions));
                            break;

                        case "tableDefinitions":
                            tableDefinitions = TableDefinitionCollection.Read(reader);
                            break;

                        default:
                            throw new XmlException();
                        }
                        break;

                    case XmlNodeType.EndElement:
                        done = true;
                        break;
                    }
                }

                if (!done)
                {
                    throw new XmlException();
                }
            }

            output.Tables = new TableIndexedCollection(tables);
            return(output);
        }
Пример #17
0
        private KpiDetails ProcessKpi(XmlReader rdr, ADOTabularTable table)
        {
            KpiDetails kpi = new KpiDetails();

            while (!(rdr.NodeType == XmlNodeType.EndElement &&
                     rdr.LocalName == "Kpi"))
            {
                while (rdr.MoveToNextAttribute())
                {
                    if (rdr.LocalName == "StatusGraphic")
                    {
                        kpi.Graphic = rdr.Value;
                    }
                }
                if (rdr.NodeType == XmlNodeType.Element &&
                    rdr.LocalName == "KpiGoal")
                {
                    while (!(rdr.NodeType == XmlNodeType.EndElement &&
                             rdr.LocalName == "KpiGoal"))
                    {
                        if (rdr.NodeType == XmlNodeType.Element &&
                            rdr.LocalName == "PropertyRef")
                        {
                            while (rdr.MoveToNextAttribute())
                            {
                                if (rdr.LocalName == "Name")
                                {
                                    kpi.Goal = rdr.Value;
                                }
                            }
                        }
                        rdr.Read();
                    }
                }


                if (rdr.NodeType == XmlNodeType.Element &&
                    rdr.LocalName == "KpiStatus")
                {
                    while (!(rdr.NodeType == XmlNodeType.EndElement &&
                             rdr.LocalName == "KpiStatus"))
                    {
                        if (rdr.NodeType == XmlNodeType.Element &&
                            rdr.LocalName == "PropertyRef")
                        {
                            while (rdr.MoveToNextAttribute())
                            {
                                if (rdr.LocalName == "Name")
                                {
                                    kpi.Status = rdr.Value;
                                }
                            }
                        }
                        rdr.Read();
                    }
                }

                rdr.Read();
            }
            return(kpi);
        }
Пример #18
0
 internal void ReadContentFrom(XmlReader r, LoadOptions o)
 {
     if ((o & (LoadOptions.SetBaseUri | LoadOptions.SetLineInfo)) == 0)
     {
         ReadContentFrom(r);
         return;
     }
     if (r.ReadState != ReadState.Interactive) throw new InvalidOperationException(SR.InvalidOperation_ExpectedInteractive);
     XContainer c = this;
     XNode n = null;
     NamespaceCache eCache = new NamespaceCache();
     NamespaceCache aCache = new NamespaceCache();
     string baseUri = (o & LoadOptions.SetBaseUri) != 0 ? r.BaseURI : null;
     IXmlLineInfo li = (o & LoadOptions.SetLineInfo) != 0 ? r as IXmlLineInfo : null;
     do
     {
         string uri = r.BaseURI;
         switch (r.NodeType)
         {
             case XmlNodeType.Element:
                 {
                     XElement e = new XElement(eCache.Get(r.NamespaceURI).GetName(r.LocalName));
                     if (baseUri != null && baseUri != uri)
                     {
                         e.SetBaseUri(uri);
                     }
                     if (li != null && li.HasLineInfo())
                     {
                         e.SetLineInfo(li.LineNumber, li.LinePosition);
                     }
                     if (r.MoveToFirstAttribute())
                     {
                         do
                         {
                             XAttribute a = new XAttribute(aCache.Get(r.Prefix.Length == 0 ? string.Empty : r.NamespaceURI).GetName(r.LocalName), r.Value);
                             if (li != null && li.HasLineInfo())
                             {
                                 a.SetLineInfo(li.LineNumber, li.LinePosition);
                             }
                             e.AppendAttributeSkipNotify(a);
                         } while (r.MoveToNextAttribute());
                         r.MoveToElement();
                     }
                     c.AddNodeSkipNotify(e);
                     if (!r.IsEmptyElement)
                     {
                         c = e;
                         if (baseUri != null)
                         {
                             baseUri = uri;
                         }
                     }
                     break;
                 }
             case XmlNodeType.EndElement:
                 {
                     if (c.content == null)
                     {
                         c.content = string.Empty;
                     }
                     // Store the line info of the end element tag.
                     // Note that since we've got EndElement the current container must be an XElement
                     XElement e = c as XElement;
                     Debug.Assert(e != null, "EndElement received but the current container is not an element.");
                     if (e != null && li != null && li.HasLineInfo())
                     {
                         e.SetEndElementLineInfo(li.LineNumber, li.LinePosition);
                     }
                     if (c == this) return;
                     if (baseUri != null && c.HasBaseUri)
                     {
                         baseUri = c.parent.BaseUri;
                     }
                     c = c.parent;
                     break;
                 }
             case XmlNodeType.Text:
             case XmlNodeType.SignificantWhitespace:
             case XmlNodeType.Whitespace:
                 if ((baseUri != null && baseUri != uri) ||
                     (li != null && li.HasLineInfo()))
                 {
                     n = new XText(r.Value);
                 }
                 else
                 {
                     c.AddStringSkipNotify(r.Value);
                 }
                 break;
             case XmlNodeType.CDATA:
                 n = new XCData(r.Value);
                 break;
             case XmlNodeType.Comment:
                 n = new XComment(r.Value);
                 break;
             case XmlNodeType.ProcessingInstruction:
                 n = new XProcessingInstruction(r.Name, r.Value);
                 break;
             case XmlNodeType.DocumentType:
                 n = new XDocumentType(r.LocalName, r.GetAttribute("PUBLIC"), r.GetAttribute("SYSTEM"), r.Value);
                 break;
             case XmlNodeType.EntityReference:
                 if (!r.CanResolveEntity) throw new InvalidOperationException(SR.InvalidOperation_UnresolvedEntityReference);
                 r.ResolveEntity();
                 break;
             case XmlNodeType.EndEntity:
                 break;
             default:
                 throw new InvalidOperationException(SR.Format(SR.InvalidOperation_UnexpectedNodeType, r.NodeType));
         }
         if (n != null)
         {
             if (baseUri != null && baseUri != uri)
             {
                 n.SetBaseUri(uri);
             }
             if (li != null && li.HasLineInfo())
             {
                 n.SetLineInfo(li.LineNumber, li.LinePosition);
             }
             c.AddNodeSkipNotify(n);
             n = null;
         }
     } while (r.Read());
 }
Пример #19
0
        private void ProcessHierarchy(XmlReader rdr, ADOTabularTable table, string eEntityType)
        {
            var    hierName          = "";
            string hierCap           = null;
            var    hierHidden        = false;
            ADOTabularHierarchy hier = null;
            ADOTabularLevel     lvl  = null;
            string lvlName           = "";
            string lvlCaption        = "";
            string lvlRef            = "";

            while (!(rdr.NodeType == XmlNodeType.EndElement &&
                     rdr.LocalName == "Hierarchy"))
            {
                if (rdr.NodeType == XmlNodeType.Element &&
                    rdr.LocalName == "Hierarchy")
                {
                    while (rdr.MoveToNextAttribute())
                    {
                        switch (rdr.LocalName)
                        {
                        case "Hidden":
                            hierHidden = bool.Parse(rdr.Value);
                            break;

                        case "Name":
                            hierName = rdr.Value;
                            break;

                        case "Caption":
                            hierCap = rdr.Value;
                            break;
                        }
                    }
                    string structure = GetHierarchStructure(table, hierName, hierCap);
                    hier = new ADOTabularHierarchy(table, hierName, hierName, hierCap ?? hierName, "", hierHidden, ADOTabularObjectType.Hierarchy, "", structure);
                    table.Columns.Add(hier);
                    rdr.Read();
                }

                while (!(rdr.NodeType == XmlNodeType.EndElement &&
                         rdr.LocalName == "Level"))
                {
                    if ((rdr.NodeType == XmlNodeType.Element) &&
                        (rdr.LocalName == "Level"))
                    {
                        while (rdr.MoveToNextAttribute())
                        {
                            switch (rdr.LocalName)
                            {
                            case "Name":
                                lvlName = rdr.Value;
                                break;

                            case "Caption":
                                lvlCaption = rdr.Value;
                                break;
                            }
                        }
                    }

                    if ((rdr.NodeType == XmlNodeType.Element) &&
                        (rdr.LocalName == "PropertyRef"))
                    {
                        while (rdr.MoveToNextAttribute())
                        {
                            switch (rdr.LocalName)
                            {
                            case "Name":
                                lvlRef = rdr.Value;
                                break;
                            }
                        }
                    }

                    rdr.Read();
                } //End of Level

                lvl           = new ADOTabularLevel(table.Columns.GetByPropertyRef(lvlRef));
                lvl.LevelName = lvlName;
                lvl.Caption   = lvlCaption;
                hier.Levels.Add(lvl);
                lvlName    = "";
                lvlCaption = "";
                lvlRef     = "";
                while (true)
                {
                    if (rdr.NodeType == XmlNodeType.Element && rdr.LocalName == "Level")
                    {
                        break;
                    }
                    if (rdr.NodeType == XmlNodeType.EndElement && rdr.LocalName == "Hierarchy")
                    {
                        break;
                    }
                    rdr.Read();
                }
            }
        }
        /// PRIVATE METHODS ///
        /// 
        /* Method which extracts the attributes from an XML node.
         * All attributes in the XML file are declared here. Each
         * should have a unique name. It would be possible to allow
         * node scoped attributes by adding extra parameters. Might
         * do this in the future if need this method to do it. */
        private bool ExtractAttributes(XmlReader reader)
        {
            if (reader.HasAttributes) {
                while (reader.MoveToNextAttribute()) {
                    // Console.WriteLine(reader.Name);
                    switch (reader.Name) {
                        /* Jira Config variables */
                        case "host":
                            jira_config.data.Add("host", reader.Value);
                            break;
                        case "user":
                            jira_config.data.Add("user", reader.Value);
                            break;
                        case "pass":
                            jira_config.data.Add("pass", reader.Value);
                            break;

                        /* File Config variables */
                        case "outputDir":
                            file_config.output.Add("output_dir", reader.Value);
                            break;
                        case "outputName":
                            file_config.output.Add("output_name", reader.Value);
                            break;
                        case "outputExt":
                            file_config.output.Add("output_ext", reader.Value);
                            break;

                        /* Email Config variables */
                        case "serverName":
                            email_config.email.Add("server_name", reader.Value);
                            break;
                        case "serverPort":
                            email_config.email.Add("server_port", reader.Value);
                            break;
                        case "senderEmail":
                            email_config.email.Add("sender_email", reader.Value);
                            break;
                        case "emailSubject":
                            email_config.email.Add("email_subject", reader.Value);
                            break;
                        case "emailBody":
                            email_config.email.Add("email_body", reader.Value);
                            break;
                        case "emailTemplate":
                            email_config.email.Add("email_template", reader.Value);
                            break;
                        case "emailType":
                            email_config.email.Add("email_type", reader.Value);
                            break;

                        /* Template config */
                        case "placeHolder":
                            string ph = reader.Value;
                            if (reader.MoveToNextAttribute()) {
                                if (reader.Name == "content") {
                                    // Console.WriteLine("Template Markup defined: " + ph + " ; " + reader.Value);
                                    template_config.markup_delim.Add(ph, reader.Value);
                                }
                                else
                                    Console.WriteLine("Unknown template configuration attribute: " + reader.Name);
                            }
                            else
                                Console.WriteLine("Unable to process Template Attribute: " + ph);
                            break;

                        default:
                            Console.WriteLine("Unknown report configuration attribute: " + reader.Name);
                            return false;
                    }
                }
            }

            return true;
        }
Пример #21
0
        public void ValidateWithXmlReader(XmlSchemaSet schemas, string xml, string xsd)
        {
            XmlNamespaceManager      namespaceManager = new XmlNamespaceManager(new NameTable());
            XmlSchemaValidationFlags validationFlags  = XmlSchemaValidationFlags.ProcessIdentityConstraints |
                                                        XmlSchemaValidationFlags.AllowXmlAttributes;
            XmlSchemaValidator validator = new XmlSchemaValidator(namespaceManager.NameTable, schemas, namespaceManager, validationFlags);

            validator.Initialize();
            using (XmlReader r = XmlReader.Create(xsd))
            {
                while (r.Read())
                {
                    switch (r.NodeType)
                    {
                    case XmlNodeType.Element:
                        namespaceManager.PushScope();
                        if (r.MoveToFirstAttribute())
                        {
                            do
                            {
                                if (r.NamespaceURI == "http://www.w3.org/2000/xmlns/")
                                {
                                    namespaceManager.AddNamespace(r.LocalName, r.Value);
                                }
                            } while (r.MoveToNextAttribute());
                            r.MoveToElement();
                        }
                        validator.ValidateElement(r.LocalName, r.NamespaceURI, null, null, null, null, null);
                        if (r.MoveToFirstAttribute())
                        {
                            do
                            {
                                if (r.NamespaceURI != "http://www.w3.org/2000/xmlns/")
                                {
                                    validator.ValidateAttribute(r.LocalName, r.NamespaceURI, r.Value, null);
                                }
                            } while (r.MoveToNextAttribute());
                            r.MoveToElement();
                        }
                        validator.ValidateEndOfAttributes(null);
                        if (r.IsEmptyElement)
                        {
                            goto case XmlNodeType.EndElement;
                        }
                        break;

                    case XmlNodeType.EndElement:
                        validator.ValidateEndElement(null);
                        namespaceManager.PopScope();
                        break;

                    case XmlNodeType.Text:
                        validator.ValidateText(r.Value);
                        break;

                    case XmlNodeType.SignificantWhitespace:
                    case XmlNodeType.Whitespace:
                        validator.ValidateWhitespace(r.Value);
                        break;

                    default:
                        break;
                    }
                }
                validator.EndValidation();
            }
            XmlReaderSettings rs = new XmlReaderSettings();

            rs.ValidationEventHandler += new ValidationEventHandler(ValidationCallback);
            rs.ValidationType          = ValidationType.Schema;
            rs.Schemas.XmlResolver     = new XmlUrlResolver();
            rs.Schemas.Add(null, XmlReader.Create(xsd));

            using (XmlReader r = XmlReader.Create(xml, rs))
            {
                while (r.Read())
                {
                    ;
                }
            }
            Assert.Equal(warningCount, 0);
            Assert.Equal(errorCount, 0);
        }
Пример #22
0
        private XmlElement LoadElementNode(bool root)
        {
            Debug.Assert(reader.NodeType == XmlNodeType.Element);

            XmlReader r             = reader;
            bool      fEmptyElement = r.IsEmptyElement;

            XmlElement element = dummyDocument.CreateElement(r.Prefix, r.LocalName, r.NamespaceURI);

            element.IsEmpty = fEmptyElement;

            if (root)
            {
                parentNode = element;
            }
            else
            {
                XmlAttributeCollection attributes = element.Attributes;
                if (r.MoveToFirstAttribute())
                {
                    do
                    {
                        if (Ref.Equal(r.NamespaceURI, schemaNames.NsXmlNs))   //Namespace Attribute
                        {
                            annotationNSManager.AddNamespace(r.Prefix.Length == 0 ? string.Empty : reader.LocalName, reader.Value);
                        }
                        XmlAttribute attr = LoadAttributeNode();
                        attributes.Append(attr);
                    } while(r.MoveToNextAttribute());
                }
                r.MoveToElement();
                string ns = annotationNSManager.LookupNamespace(r.Prefix);
                if (ns == null)
                {
                    XmlAttribute attr = CreateXmlNsAttribute(r.Prefix, namespaceManager.LookupNamespace(r.Prefix));
                    attributes.Append(attr);
                }
                else if (ns.Length == 0)   //string.Empty prefix is mapped to string.Empty NS by default
                {
                    string elemNS = namespaceManager.LookupNamespace(r.Prefix);
                    if (elemNS != string.Empty)
                    {
                        XmlAttribute attr = CreateXmlNsAttribute(r.Prefix, elemNS);
                        attributes.Append(attr);
                    }
                }

                while (r.MoveToNextAttribute())
                {
                    if (r.Prefix.Length != 0)
                    {
                        string attNS = annotationNSManager.LookupNamespace(r.Prefix);
                        if (attNS == null)
                        {
                            XmlAttribute attr = CreateXmlNsAttribute(r.Prefix, namespaceManager.LookupNamespace(r.Prefix));
                            attributes.Append(attr);
                        }
                    }
                }
                r.MoveToElement();

                parentNode.AppendChild(element);
                if (!r.IsEmptyElement)
                {
                    parentNode = element;
                }
            }
            return(element);
        }
Пример #23
0
            private void AdvanceParser()
            {
                if (!_canPush)
                {
                    return;
                }

                // Check for pending events
                if (_pendingEvent != null)
                {
                    Push(_pendingEvent);
                    if (_pendingEvent is EndDocument)
                    {
                        _documentStarted = false;
                    }
                    _pendingEvent = null;
                    return;
                }

                // Check for empty buffer condition.
                // XmlParser requires that there are at least 6 characters in the stream,
                // or it will read the stream multiple times to get more data,
                // which will result in premature EOF in our case.
                if (_feeder.Length - _feeder.Position < 7 && DataAvailable)
                {
                    GetNextStreamBuffer();
                    return;
                }

                if (_parser == null)
                {
                    _parser = XmlReader.Create(_feeder, new XmlReaderSettings
                    {
                        IgnoreComments = false,
                        IgnoreProcessingInstructions = false,
                        IgnoreWhitespace             = true,
                        CloseInput       = false,
                        ConformanceLevel = ConformanceLevel.Fragment
                    });
                }

                try
                {
                    _hasNext = _parser.Read();
                }
                catch (Exception e)
                {
                    FailStage(e);
                    return;
                }

                if (!_hasNext)
                {
                    if (!_parser.EOF)
                    {
                        if (IsClosed(_stage.In))
                        {
                            _parser.Close();
                            FailStage(new IllegalStateException("Stream finished before event was fully parsed."));
                        }
                        else
                        {
                            _parser.Close();
                            FailStage(new IllegalStateException("Unknown error occured. Parsing finished before stream was finished."));
                        }
                    }
                    CompleteStage();
                    return;
                }

                switch (_parser.NodeType)
                {
                // START_ELEMENT
                case XmlNodeType.Element:
                    var attributes = new Dictionary <string, string>();
                    while (_parser.MoveToNextAttribute())
                    {
                        attributes.Add(_parser.LocalName, _parser.Value);
                    }
                    _parser.MoveToElement();

                    if (_parser.Depth == 0 && !_documentStarted)
                    {
                        // START_DOCUMENT
                        _documentStarted = true;
                        Push(StartDocument.Instance);
                        _pendingEvent = new StartElement(_parser.LocalName, attributes);
                    }
                    else
                    {
                        Push(new StartElement(_parser.LocalName, attributes));
                    }
                    return;

                // END_ELEMENT
                case XmlNodeType.EndElement:
                    Push(new EndElement(_parser.LocalName));
                    if (_parser.Depth == 0)
                    {
                        // END_DOCUMENT
                        _pendingEvent = EndDocument.Instance;
                    }
                    return;

                // CHARACTERS
                case XmlNodeType.Text:
                    Push(new Characters(_parser.Value));
                    return;

                // PROCESSING_INSTRUCTION
                case XmlNodeType.ProcessingInstruction:
                    if (_parser.Depth == 0 && !_documentStarted)
                    {
                        // START_DOCUMENT
                        _documentStarted = true;
                        Push(StartDocument.Instance);
                        _pendingEvent = new ProcessingInstruction(_parser.Name, _parser.Value);
                    }
                    else
                    {
                        Push(new ProcessingInstruction(_parser.Name, _parser.Value));
                    }
                    return;

                // COMMENT
                case XmlNodeType.Comment:
                    Push(new Comment(_parser.Value));
                    return;

                // CDATA
                case XmlNodeType.CDATA:
                    Push(new CData(_parser.Value));
                    return;

                // Do not support DTD, SPACE, NAMESPACE, NOTATION_DECLARATION, ENTITY_DECLARATION
                // ATTRIBUTE is handled in START_ELEMENT implicitly
                // EVENT_INCOMPLETE is handled directly in AsyncXmlStream
                default:
                    if (_feeder.Length - _feeder.Position < 7 && DataAvailable)
                    {
                        GetNextStreamBuffer();
                        return;
                    }
                    AdvanceParser();
                    return;
                }
            }
Пример #24
0
        /// <summary>
        /// The reader is positioned on a &lt;dependentassembly&gt; element--read it.
        /// </summary>
        /// <param name="reader"></param>
        internal void Read(XmlReader reader)
        {
            ArrayList redirects = new ArrayList();

            if (_bindingRedirects != null)
            {
                redirects.AddRange(_bindingRedirects);
            }

            while (reader.Read())
            {
                // Look for the end element.
                if (reader.NodeType == XmlNodeType.EndElement && AppConfig.StringEquals(reader.Name, "dependentassembly"))
                {
                    break;
                }

                // Look for a <assemblyIdentity> element
                if (reader.NodeType == XmlNodeType.Element && AppConfig.StringEquals(reader.Name, "assemblyIdentity"))
                {
                    string name           = null;
                    string publicKeyToken = "null";
                    string culture        = "neutral";

                    // App.config seems to have mixed case attributes.
                    while (reader.MoveToNextAttribute())
                    {
                        if (AppConfig.StringEquals(reader.Name, "name"))
                        {
                            name = reader.Value;
                        }
                        else
                        if (AppConfig.StringEquals(reader.Name, "publicKeyToken"))
                        {
                            publicKeyToken = reader.Value;
                        }
                        else
                        if (AppConfig.StringEquals(reader.Name, "culture"))
                        {
                            culture = reader.Value;
                        }
                    }

                    string assemblyName = String.Format
                                          (
                        CultureInfo.InvariantCulture,
                        "{0}, Version=0.0.0.0, Culture={1}, PublicKeyToken={2}",
                        name,
                        culture,
                        publicKeyToken
                                          );

                    try
                    {
                        _partialAssemblyName = new AssemblyNameExtension(assemblyName).AssemblyName;
                    }
                    catch (System.IO.FileLoadException e)
                    {
                        // A badly formed assembly name.
                        ErrorUtilities.VerifyThrowArgument(false, e, "AppConfig.InvalidAssemblyIdentityFields");
                    }
                }

                // Look for a <bindingRedirect> element.
                if (reader.NodeType == XmlNodeType.Element && AppConfig.StringEquals(reader.Name, "bindingRedirect"))
                {
                    BindingRedirect bindingRedirect = new BindingRedirect();
                    bindingRedirect.Read(reader);
                    redirects.Add(bindingRedirect);
                }
            }
            _bindingRedirects = (BindingRedirect[])redirects.ToArray(typeof(BindingRedirect));
        }
Пример #25
0
        private void Update(object sender, DoWorkEventArgs e)
        {
            string version = (string)(e.Argument);

            if (worker.CancellationPending)
            {
                e.Cancel = true;
                return;
            }
            worker.ReportProgress(0);

            SortedDictionary <string, List <Change> > versionChanges = new SortedDictionary <string, List <Change> >();

            try
            {
                // Download the content of the Versions.xml
                using (WebClient client = new WebClient()
                {
                    Proxy = null
                })
                    using (StringReader reader = new StringReader(client.DownloadString("https://www.dropbox.com/s/fk3ox7fx0i0w8me/Versions.xml?dl=1")))
                        using (XmlReader xml = XmlReader.Create(reader))
                        {
                            if (worker.CancellationPending)
                            {
                                e.Cancel = true;
                                return;
                            }
                            worker.ReportProgress(2);

                            // Load versionChanges
                            while (xml.ReadToFollowing("version"))
                            {
                                using (XmlReader inner = xml.ReadSubtree())
                                {
                                    // Read version
                                    inner.ReadToFollowing("ver");
                                    inner.MoveToFirstAttribute();
                                    string ver = inner.Value;
                                    if (Math.Sign(version.CompareTo(ver)) != -1)
                                    {
                                        continue; // we need only versions which are greater than the current one
                                    }
                                    // Read changes
                                    List <Change> changes = new List <Change>();
                                    inner.ReadToFollowing("changes");
                                    using (XmlReader changesReader = inner.ReadSubtree())
                                    {
                                        while (changesReader.ReadToFollowing("change"))
                                        {
                                            changesReader.MoveToFirstAttribute();
                                            string command = changesReader.Value;

                                            changesReader.MoveToNextAttribute();
                                            string type = changesReader.Value;

                                            changesReader.MoveToNextAttribute();
                                            string arg = changesReader.Value;

                                            string url = string.Empty;
                                            if (command == "create" || command == "update")
                                            {
                                                changesReader.MoveToNextAttribute();
                                                url = changesReader.Value;
                                            }

                                            changes.Add(new Change(command, type, arg, url));
                                        }
                                    }
                                    versionChanges.Add(ver, changes);


                                    // Read change descriptions
                                    List <string> descriptions = new List <string>();
                                    bool          asd          = inner.ReadToFollowing("descriptions");
                                    using (XmlReader descrReader = inner.ReadSubtree())
                                    {
                                        while (descrReader.ReadToFollowing("description"))
                                        {
                                            descrReader.MoveToFirstAttribute();
                                            descriptions.Add(descrReader.Value);
                                        }
                                    }
                                    versionDescriptions.Add(ver, descriptions);
                                }
                            }
                        }
            }
            catch (Exception)
            {
                worker.ReportProgress(1);
                return;
            }


            if (worker.CancellationPending)
            {
                e.Cancel = true;
                return;
            }
            // Generate the final list about what should be updated, deleted etc.
            worker.ReportProgress(4);
            Thread.Sleep(3000); // To wait Great Snooper to exit!
            Dictionary <string, Change> realChanges = new Dictionary <string, Change>();

            foreach (KeyValuePair <string, List <Change> > item in versionChanges)
            {
                foreach (Change change in item.Value)
                {
                    if (!realChanges.ContainsKey(change.arg))
                    {
                        realChanges.Add(change.arg, change);
                    }
                    else
                    {
                        realChanges[change.arg] = change;
                    }
                }
            }

            if (worker.CancellationPending)
            {
                e.Cancel = true;
                return;
            }
            worker.ReportProgress(6, realChanges.Count + 1);

            using (WebClient client = new WebClient()
            {
                Proxy = null
            })
            {
                foreach (KeyValuePair <string, Change> item in realChanges)
                {
                    if (item.Value.arg.Contains("../") || item.Value.arg.Contains(":"))
                    {
                        continue;
                    }

                    string path = Path.GetFullPath(item.Value.arg);

                    if (item.Value.command == "delete")
                    {
                        switch (item.Value.type)
                        {
                        case "directory":
                            if (Directory.Exists(path))
                            {
                                Directory.Delete(path, true);
                            }
                            break;

                        case "file":
                            if (File.Exists(path))
                            {
                                File.Delete(path);
                            }
                            break;
                        }
                    }
                    else if (item.Value.command == "create" || item.Value.command == "update")
                    {
                        switch (item.Value.type)
                        {
                        case "directory":
                            if (!Directory.Exists(path))
                            {
                                Directory.CreateDirectory(path);
                            }
                            break;

                        case "file":
                            if (File.Exists(path))
                            {
                                File.Delete(path);
                            }
                            client.DownloadFile(item.Value.url, path);
                            break;
                        }
                    }

                    if (worker.CancellationPending)
                    {
                        e.Cancel = true;
                        return;
                    }
                    worker.ReportProgress(7);
                }
            }
        }
Пример #26
0
        public static Element?Read(XmlReader reader, IElementFactory elementFactory)
        {
            var elements = new List <Element>();
            var stack    = new Stack <Element>();

            while (reader.Read())
            {
                switch (reader.NodeType)
                {
                case XmlNodeType.None:
                    break;

                case XmlNodeType.Element:
                {
                    string  localName = reader.LocalName;
                    Element element;

                    if (string.IsNullOrEmpty(reader.NamespaceURI) || elementFactory.Namespaces.Contains(reader.NamespaceURI))
                    {
                        var parent = stack.Count > 0 ? stack.Peek() : null;

                        element        = elementFactory.Create(localName, parent);
                        element.Parent = parent;

                        if (reader.MoveToFirstAttribute())
                        {
                            do
                            {
                                if (string.IsNullOrEmpty(reader.NamespaceURI) || elementFactory.Namespaces.Contains(reader.NamespaceURI))
                                {
                                    string attributeName = reader.LocalName;
                                    element.Attributes.Add(attributeName, reader.Value);
                                }
                            }while (reader.MoveToNextAttribute());
                            reader.MoveToElement();
                        }

                        var children = parent != null ? parent.Children : elements;
                        children.Add(element);
                    }
                    else
                    {
                        element = new UnknownElement()
                        {
                            Tag = localName, Parent = null
                        };
                    }

                    if (!reader.IsEmptyElement)
                    {
                        stack.Push(element);
                    }
                }
                break;

                case XmlNodeType.Attribute:
                    break;

                case XmlNodeType.Text:
                {
                    var element = stack.Peek();
                    var content = new ContentElement()
                    {
                        Content = reader.Value
                    };
                    element.Children.Add(content);
                }
                break;

                case XmlNodeType.CDATA:
                {
                    var element = stack.Peek();
                    var content = new ContentElement()
                    {
                        Content = reader.Value
                    };
                    element.Children.Add(content);
                }
                break;

                case XmlNodeType.EntityReference:
                {
                    reader.ResolveEntity();
                    var element = stack.Peek();
                    var content = new ContentElement()
                    {
                        Content = reader.Value
                    };
                    element.Children.Add(content);
                }
                break;

                case XmlNodeType.Entity:
                    break;

                case XmlNodeType.ProcessingInstruction:
                    break;

                case XmlNodeType.Comment:
                    break;

                case XmlNodeType.Document:
                    break;

                case XmlNodeType.DocumentType:
                    break;

                case XmlNodeType.DocumentFragment:
                    break;

                case XmlNodeType.Notation:
                    break;

                case XmlNodeType.Whitespace:
                    break;

                case XmlNodeType.SignificantWhitespace:
                    break;

                case XmlNodeType.EndElement:
                {
                    var element = stack.Pop();

                    foreach (var child in element.Children)
                    {
                        if (child is ContentElement content)
                        {
                            element.Content += content.Content;
                        }
                    }
                }
                break;

                case XmlNodeType.EndEntity:
                    break;

                case XmlNodeType.XmlDeclaration:
                    break;

                default:
                    break;
                }
            }
            if (elements.Count == 1)
            {
                return(elements[0]);
            }
            return(null);
        }
Пример #27
0
        private static OutputGroup ReadOutputElement(XmlReader reader)
        {
            var outputNode = new OutputGroup();

            while (reader.Read())
            {
                // get the attributes
                if (reader.Name == OutputElementName && reader.HasAttributes)
                {
                    while (reader.MoveToNextAttribute())
                    {
                        switch (reader.Name)
                        {
                        case PathAttributeName:
                            outputNode.Path = reader.Value;
                            break;

                        case EncodingAttributeName:
                            outputNode.EncodingName = reader.Value;
                            break;

                        case TypeAttributeName:
                            switch (reader.Value.ToUpperInvariant())
                            {
                            case "JS":
                            case "JAVASCRIPT":
                            case "JSCRIPT":
                                outputNode.CodeType = CodeType.JavaScript;
                                break;

                            case "CSS":
                            case "STYLESHEET":
                            case "STYLESHEETS":
                                outputNode.CodeType = CodeType.StyleSheet;
                                break;
                            }
                            break;

                        case MapPathAttributeName:
                            outputNode.SymbolMap = new SymbolMap()
                            {
                                Path = reader.Value
                            };
                            break;
                        }
                    }

                    // back to element
                    reader.MoveToElement();
                }

                // process child elements
                if (reader.NodeType == XmlNodeType.Element)
                {
                    switch (reader.Name)
                    {
                    case ArgumentsElementName:
                        ReadArgumentsElement(reader.ReadSubtree(), outputNode.Arguments);
                        break;

                    case RenameElementName:
                        ReadRenameElement(reader.ReadSubtree(), outputNode.RenameIdentifiers);
                        break;

                    case NoRenameElementName:
                        ReadNoRenameElement(reader.ReadSubtree(), outputNode.NoRenameIdentifiers);
                        break;

                    case SymbolMapElementName:
                        outputNode.SymbolMap = ReadSymbolMapElement(reader.ReadSubtree());
                        break;

                    case ResourceElementName:
                        outputNode.Resources.Add(ReadResourceElement(reader.ReadSubtree()));
                        break;

                    case InputElementName:
                        outputNode.Inputs.Add(ReadInputElement(reader.ReadSubtree()));
                        break;
                    }
                }
            }

            reader.Close();
            return(outputNode);
        }
Пример #28
0
        /// <summary>
        /// Creates a Row from the XmlReader.
        /// </summary>
        /// <param name="reader">Reader to get data from.</param>
        /// <param name="table">Table for this row.</param>
        /// <returns>New row object.</returns>
        internal static Row Parse(XmlReader reader, Table table)
        {
            Debug.Assert("row" == reader.LocalName);

            bool         empty     = reader.IsEmptyElement;
            RowOperation operation = RowOperation.None;
            string       sectionId = null;
            SourceLineNumberCollection sourceLineNumbers = null;

            while (reader.MoveToNextAttribute())
            {
                switch (reader.LocalName)
                {
                case "op":
                    switch (reader.Value)
                    {
                    case "add":
                        operation = RowOperation.Add;
                        break;

                    case "delete":
                        operation = RowOperation.Delete;
                        break;

                    case "modify":
                        operation = RowOperation.Modify;
                        break;

                    default:
                        throw new WixException(WixErrors.IllegalAttributeValue(SourceLineNumberCollection.FromUri(reader.BaseURI), "row", reader.Name, reader.Value, "Add", "Delete", "Modify"));
                    }
                    break;

                case "sectionId":
                    sectionId = reader.Value;
                    break;

                case "sourceLineNumber":
                    sourceLineNumbers = new SourceLineNumberCollection(reader.Value);
                    break;

                default:
                    if (!reader.NamespaceURI.StartsWith("http://www.w3.org/", StringComparison.Ordinal))
                    {
                        throw new WixException(WixErrors.UnexpectedAttribute(SourceLineNumberCollection.FromUri(reader.BaseURI), "row", reader.Name));
                    }
                    break;
                }
            }

            Row row = table.CreateRow(sourceLineNumbers);

            row.Operation = operation;
            row.SectionId = sectionId;

            // loop through all the fields in a row
            if (!empty)
            {
                bool done  = false;
                int  field = 0;

                // loop through all the fields in a row
                while (!done && reader.Read())
                {
                    switch (reader.NodeType)
                    {
                    case XmlNodeType.Element:
                        switch (reader.LocalName)
                        {
                        case "field":
                            if (row.Fields.Length <= field)
                            {
                                if (!reader.IsEmptyElement)
                                {
                                    throw new WixException(WixErrors.UnexpectedColumnCount(SourceLineNumberCollection.FromUri(reader.BaseURI), table.Name));
                                }
                            }
                            else
                            {
                                row.fields[field].Parse(reader);
                            }
                            ++field;
                            break;

                        default:
                            throw new WixException(WixErrors.UnexpectedElement(SourceLineNumberCollection.FromUri(reader.BaseURI), "row", reader.Name));
                        }
                        break;

                    case XmlNodeType.EndElement:
                        done = true;
                        break;
                    }
                }

                if (!done)
                {
                    throw new WixException(WixErrors.ExpectedEndElement(SourceLineNumberCollection.FromUri(reader.BaseURI), "row"));
                }
            }

            return(row);
        }
Пример #29
0
        internal void Parse(XmlReader reader)
        {
            GetPositionInfo(reader);

            var hasEndElement = !reader.IsEmptyElement;

            Debug.Assert(reader.NodeType == XmlNodeType.Element);
            for (var more = reader.MoveToFirstAttribute(); more; more = reader.MoveToNextAttribute())
            {
                ParseAttribute(reader);
            }
            HandleAttributesComplete();

            var done = !hasEndElement;
            var skipToNextElement = false;

            while (!done)
            {
                if (skipToNextElement)
                {
                    skipToNextElement = false;
                    reader.Skip();
                    if (reader.EOF)
                    {
                        break;
                    }
                }
                else
                {
                    if (!reader.Read())
                    {
                        break;
                    }
                }
                switch (reader.NodeType)
                {
                case XmlNodeType.Element:
                    skipToNextElement = ParseElement(reader);
                    break;

                case XmlNodeType.EndElement:
                {
                    done = true;
                    break;
                }

                case XmlNodeType.CDATA:
                case XmlNodeType.Text:
                case XmlNodeType.SignificantWhitespace:
                    ParseText(reader);
                    break;

                // we ignore these childless elements
                case XmlNodeType.Whitespace:
                case XmlNodeType.XmlDeclaration:
                case XmlNodeType.Comment:
                case XmlNodeType.Notation:
                case XmlNodeType.ProcessingInstruction:
                {
                    break;
                }

                // we ignore these elements that can have children
                case XmlNodeType.DocumentType:
                case XmlNodeType.EntityReference:
                {
                    skipToNextElement = true;
                    break;
                }

                default:
                {
                    AddError(
                        ErrorCode.UnexpectedXmlNodeType, EdmSchemaErrorSeverity.Error, reader,
                        Strings.UnexpectedXmlNodeType(reader.NodeType));
                    skipToNextElement = true;
                    break;
                }
                }
            }
            HandleChildElementsComplete();
            if (reader.EOF &&
                reader.Depth > 0)
            {
                AddError(
                    ErrorCode.MalformedXml, EdmSchemaErrorSeverity.Error, 0, 0,
                    Strings.MalformedXml(LineNumber, LinePosition));
            }
        }
Пример #30
0
        public void work()
        {
            string change = "";
            string sendd  = "";

            string city = "";
            // string city1 = "";
            double buyy;
            double selll;

            double[] buy  = new double[20];
            double[] sell = new double[20];
            for (int i = 1; i < 20; i++)
            {
                buy[i]  = -1;
                sell[i] = -1;
            }

            double[] buytest  = new double[20];
            double[] selltest = new double[20];
            for (int i = 1; i < 20; i++)
            {
                buytest[i]  = -1;
                selltest[i] = -1;
            }

            //int count = 0;
            String          link     = "http://www.sjc.com.vn/xml/tygiavang.xml";
            HttpWebRequest  request  = WebRequest.CreateHttp(link);
            HttpWebResponse response = (HttpWebResponse)request.GetResponse();
            StreamReader    sr       = new StreamReader(response.GetResponseStream(), Encoding.UTF8);
            string          content  = sr.ReadToEnd();

            sr.Close();

            XmlReader reader = XmlReader.Create(new StringReader(content));

            reader.ReadToFollowing("ratelist");
            reader.MoveToFirstAttribute(); //thuoc tinh "updated"
            System.Console.WriteLine("Cap nhat luc: " + reader.Value);
            OutputText("Cap nhat luc: " + reader.Value);
            reader.MoveToNextAttribute(); // Thuoc tinh unit
            System.Console.WriteLine("Don vi tinh: " + reader.Value);
            OutputText("Don vi tinh: " + reader.Value);
            while (reader.ReadToFollowing("city")) //duyet cac Element city
            {
                reader.MoveToFirstAttribute();
                System.Console.WriteLine("Thanh pho: " + reader.Value);
                city = reader.Value;
                OutputText("Thanh pho: " + reader.Value);

                //  while (r.ReadToFollowing("item")) { count++; }
                //while (r.ReadToFollowing("item"))
                if (city == "Hồ Chí Minh")
                {
                    reader.MoveToElement();
                    XmlReader r = reader.ReadSubtree();
                    for (int i = 1; i <= 8; i++)
                    {
                        r.ReadToFollowing("item");
                        r.MoveToFirstAttribute();//buy
                        System.Console.WriteLine("Gia mua: " + reader.Value);
                        buy[i] = Convert.ToDouble(reader.Value);
                        if (buy[i] >= 47.750)
                        {
                            change += "Gia mua: " + Convert.ToString(buy[i]) + "/";
                            //  MessageBox.Show(Convert.ToString( buy[i]));
                            buytest[i] = buy[i];
                        }
                        OutputText("Gia mua: " + reader.Value);
                        r.MoveToNextAttribute(); //sell
                        System.Console.WriteLine("Gia ban: " + reader.Value);
                        sell[i] = Convert.ToDouble(reader.Value);
                        if (sell[i] >= 48.635)
                        {
                            change     += "Gia ban: " + Convert.ToString(sell[i]) + "/";
                            selltest[i] = selltest[i];
                        }
                        OutputText("Gia ban: " + reader.Value);
                        r.MoveToNextAttribute(); //type
                        System.Console.WriteLine("Loai: " + reader.Value);
                        if (buytest[i] != (-1) || selltest[i] != (-1))
                        {
                            change += ("loai: " + reader.Value + "\n\t");
                        }
                        OutputText("Loai: " + reader.Value);
                    }
                }
                if (city != "Hồ Chí Minh")
                {
                    reader.MoveToElement();
                    XmlReader r = reader.ReadSubtree();
                    while (r.ReadToFollowing("item"))
                    {
                        // r.ReadToFollowing("item");
                        r.MoveToFirstAttribute();//buy
                        System.Console.WriteLine("Gia mua: " + reader.Value);
                        buyy = Convert.ToDouble(reader.Value);
                        if (buyy >= 47.750)
                        {
                            change += "Gia mua: " + Convert.ToString(buyy) + "/";
                        }
                        OutputText("Gia mua: " + reader.Value);
                        r.MoveToNextAttribute(); //sell
                        System.Console.WriteLine("Gia ban: " + reader.Value);
                        selll = Convert.ToDouble(reader.Value);
                        if (selll >= 48.635)
                        {
                            change += "Gia ban: " + Convert.ToString(selll) + "/";
                        }
                        OutputText("Gia ban: " + reader.Value);
                        r.MoveToNextAttribute(); //type
                        System.Console.WriteLine("Loai: " + reader.Value);
                        if (change != "")
                        {
                            change += "loai: " + reader.Value + "/";
                        }
                        OutputText("Loai: " + reader.Value);
                    }
                }
                if (change != "")
                {
                    change += " cua tp: " + city + "\n\r";
                    sendd  += change;
                    change  = "";
                }
            }
            System.Console.WriteLine(sendd);
            string sent    = sendd.Replace("\n\r", "<br/>");
            string hcmSent = sent.Replace("\n\t", "<br/>");

            if (sendd != "")
            {
                MessageBox.Show(sendd); maill(hcmSent);
            }
        }
Пример #31
0
        private IPersistEntity ReadEntity(XmlReader input, Type suggestedType = null)
        {
            var expType = GetExpresType(input);

            if (expType == null && suggestedType != null && !suggestedType.IsAbstract)
            {
                expType = _metadata.ExpressType(suggestedType);
            }
            if (expType == null)
            {
                var typeName = input.GetAttribute("type") ?? input.LocalName;
                throw new XbimParserException(typeName + "is not an IPersistEntity type");
            }

            var id = GetId(input, expType, out bool isRef);

            if (!id.HasValue)
            {
                throw new XbimParserException("Wrong entity XML format");
            }

            var entity = _getOrCreate(id.Value, expType.Type);

            if (isRef)
            {
                if (!input.IsEmptyElement)
                {
                    // Consume anything until the end of the entity.
                    // this is usualy empty element but some people put data in there as well to indicate some of the
                    // content for humans reading the XML (as much as it is silly)
                    var depth      = input.Depth;
                    var hasContent = false;
                    while (input.Read())
                    {
                        if (input.NodeType == XmlNodeType.EndElement && input.Depth == depth)
                        {
                            break;
                        }
                        hasContent = true;
                    }
                    if (hasContent)
                    {
                        // Log a warning as it is a wrong practise to put content in ref elements
                        Logger.LogWarning("Reference to element {0}, ref='{1}' is not empty. This is a wrong practise.", entity.ExpressType.Name, id);
                    }
                }
                return(entity);
            }

            //read all attributes
            while (input.MoveToNextAttribute())
            {
                var pInfo = GetMetaProperty(expType, input.LocalName);
                if (pInfo == null)
                {
                    continue;
                }
                SetPropertyFromString(pInfo, entity, input.Value, null);
            }
            input.MoveToElement();

            if (input.IsEmptyElement)
            {
                _finish(entity);
                return(entity);
            }

            //read all element properties
            var pDepth = input.Depth;

            while (input.Read())
            {
                if (input.NodeType == XmlNodeType.EndElement && input.Depth == pDepth)
                {
                    break;
                }
                if (input.NodeType != XmlNodeType.Element)
                {
                    continue;
                }
                var pInfo = GetMetaProperty(expType, input.LocalName);
                if (pInfo == null)
                {
                    continue;
                }
                SetPropertyFromElement(pInfo, entity, input, null);
                if (input.NodeType == XmlNodeType.EndElement && input.Depth == pDepth)
                {
                    break;
                }
            }

            //finalize
            _finish(entity);
            return(entity);
        }
Пример #32
0
        public void convertXMLtoDrawing()
        {
            Document currentDocument = Autodesk.AutoCAD.ApplicationServices.Application.DocumentManager.MdiActiveDocument;
            Database currentDatabase = currentDocument.Database;
            Editor   editor          = currentDocument.Editor;

            OpenFileDialog fileDialog = new OpenFileDialog("Select .xml-file for import", null, "xml", "XMLfileToLink", OpenFileDialog.OpenFileDialogFlags.DoNotTransferRemoteFiles);

            System.Windows.Forms.DialogResult result = fileDialog.ShowDialog();

            if (result != System.Windows.Forms.DialogResult.OK)
            {
                editor.WriteMessage("\nWrong file format.");
                return;
            }

            XmlReaderSettings settings = new XmlReaderSettings();

            settings.IgnoreWhitespace             = true;
            settings.IgnoreComments               = true;
            settings.IgnoreProcessingInstructions = true;
            XmlReader reader = XmlReader.Create(fileDialog.Filename, settings);

            String          objectType = "";
            String          objectName = "";
            List <Vector2D> vectorList = null;

            Vector2D[] vectorArray;
            double     x_Value = 0;
            double     y_Value = 0;
            Polygon2D  newPolygon;
            Segment2D  newSegment;
            double     maxX_Value = 0;
            double     maxY_Value = 0;
            double     minX_Value = 0;
            double     minY_Value = 0;

            bool objectUnderConstruction = false;

            while (reader.Read())
            {
                switch (reader.NodeType)
                {
                case XmlNodeType.XmlDeclaration:
                    break;

                case XmlNodeType.Element:

                    if (reader.Name.Equals(scenario_Node))
                    {
                        if (reader.HasAttributes)
                        {
                            while (reader.MoveToNextAttribute())
                            {
                                if (reader.Name.Equals(id_Attribute))
                                {
                                    editor.WriteMessage("\n" + reader.Name + "=" + reader.Value);
                                }
                                else if (reader.Name.Equals(name_Attribute))
                                {
                                    editor.WriteMessage("\n" + reader.Name + "=" + reader.Value);
                                }
                                else if (reader.Name.Equals(maxX_Attribute))
                                {
                                    maxX_Value = reader.ReadContentAsDouble();
                                }
                                else if (reader.Name.Equals(maxY_Attribute))
                                {
                                    maxY_Value = reader.ReadContentAsDouble();
                                }
                                else if (reader.Name.Equals(minX_Attribute))
                                {
                                    minX_Value = reader.ReadContentAsDouble();
                                }
                                else if (reader.Name.Equals(minY_Attribute))
                                {
                                    minY_Value = reader.ReadContentAsDouble();

                                    ViewTableRecord oldView  = editor.GetCurrentView();
                                    ViewTableRecord newView  = (ViewTableRecord)oldView.Clone();
                                    Point2d         minPoint = new Point2d(minX_Value, minY_Value);
                                    Point2d         maxPoint = new Point2d(maxX_Value, maxY_Value);

                                    newView.CenterPoint = minPoint + ((maxPoint - minPoint) / 2.0);
                                    newView.Height      = maxPoint.Y - minPoint.Y;
                                    newView.Width       = maxPoint.X - minPoint.X;
                                    editor.SetCurrentView(newView);
                                }
                            }
                        }
                    }
                    else if (reader.Name.Equals(area_Node) || reader.Name.Equals(obstacle_Node))
                    {
                        objectUnderConstruction = true;
                        vectorList = new List <Vector2D>();

                        if (reader.HasAttributes)
                        {
                            while (reader.MoveToNextAttribute())
                            {
                                if (reader.Name.Equals(name_Attribute))
                                {
                                    objectName = reader.Value;
                                }
                                else if (reader.Name.Equals(type_Attribute))
                                {
                                    objectType = reader.Value;
                                }
                            }
                        }
                    }
                    else if (reader.Name.Equals(point_Node))
                    {
                        if (objectUnderConstruction)
                        {
                            if (reader.HasAttributes)
                            {
                                while (reader.MoveToNextAttribute())
                                {
                                    if (reader.Name.Equals(x_Attribute))
                                    {
                                        x_Value = reader.ReadContentAsDouble();
                                    }
                                    else if (reader.Name.Equals(y_Attribute))
                                    {
                                        y_Value = reader.ReadContentAsDouble();
                                    }
                                }
                            }

                            vectorList.Add(new Vector2D(x_Value, y_Value));
                        }
                    }
                    break;

                case XmlNodeType.EndElement:

                    if (reader.Name.Equals(area_Node))
                    {
                        vectorArray = vectorList.ToArray();
                        newPolygon  = new Polygon2D(vectorArray, objectName);
                        GeometryFactory.polygon2DtoPolyline(newPolygon, objectType, currentDocument);
                        objectUnderConstruction = false;
                    }
                    else if (reader.Name.Equals(obstacle_Node))
                    {
                        vectorArray = vectorList.ToArray();

                        if (objectType.Equals(wall_Value) && vectorArray[0].isEqualTo(vectorArray[vectorArray.Length - 1]))
                        {
                            newPolygon = new Polygon2D(vectorArray, objectName);
                            GeometryFactory.polygon2DtoPolyline(newPolygon, objectType, currentDocument);
                        }
                        else if (objectType.Equals(wall_Value))
                        {
                            newSegment = new Segment2D(vectorArray, objectName);
                            GeometryFactory.segment2DtoPolyline(newSegment, objectType, currentDocument);
                        }
                        else if (objectType.Equals(solid_Value))
                        {
                            newPolygon = new Polygon2D(vectorArray, objectName);
                            GeometryFactory.polygon2DtoPolyline(newPolygon, objectType, currentDocument);
                        }

                        objectUnderConstruction = false;
                    }
                    break;

                default:
                    break;
                }
            }

            reader.Close();
        }
Пример #33
0
        internal static LoggerSettings FromXml(XmlReader reader)
        {
            var elementName = reader.Name;
            var empty       = reader.IsEmptyElement;
            var settings    = new LoggerSettings
            {
                IsEnabled = true
            };

            // Read attributes.
            if (reader.HasAttributes)
            {
                while (reader.MoveToNextAttribute())
                {
                    switch (reader.Name.ToLowerInvariant())
                    {
                    case Constants.LoggerFriendlyNameLower:
                        settings.FriendlyName = reader.Value;
                        break;

                    case Constants.LoggerUriName:
                        try
                        {
                            settings.Uri = new Uri(reader.Value);
                        }
                        catch (UriFormatException)
                        {
                            throw new SettingsException(
                                      String.Format(
                                          CultureInfo.CurrentCulture,
                                          Resources.Resources.InvalidUriInSettings,
                                          reader.Value,
                                          elementName));
                        }
                        break;

                    case Constants.LoggerAssemblyQualifiedNameLower:
                        settings.AssemblyQualifiedName = reader.Value;
                        break;

                    case Constants.LoggerCodeBaseLower:
                        settings.CodeBase = reader.Value;
                        break;

                    case Constants.LoggerEnabledName:
                        bool.TryParse(reader.Value, out var value);
                        settings.IsEnabled = value;
                        break;

                    default:
                        throw new SettingsException(
                                  string.Format(
                                      CultureInfo.CurrentCulture,
                                      Resources.Resources.InvalidSettingsXmlAttribute,
                                      elementName,
                                      reader.Name));
                    }
                }
            }

            // Check for required atttributes.
            if (string.IsNullOrWhiteSpace(settings.FriendlyName) &&
                string.IsNullOrWhiteSpace(settings.Uri?.ToString()) &&
                string.IsNullOrWhiteSpace(settings.AssemblyQualifiedName))
            {
                throw new SettingsException(
                          string.Format(
                              CultureInfo.CurrentCulture,
                              Resources.Resources.MissingLoggerAttributes,
                              elementName,
                              Constants.LoggerFriendlyName));
            }

            // Move to next node.
            reader.Read();

            // Return empty settings if previous element is empty.
            if (empty)
            {
                return(settings);
            }

            // Read inner elements.
            while (reader.NodeType == XmlNodeType.Element)
            {
                switch (reader.Name.ToLowerInvariant())
                {
                case Constants.LoggerConfigurationNameLower:
                    var document = new XmlDocument();
                    var element  = document.CreateElement(reader.Name);
                    element.InnerXml       = reader.ReadInnerXml();
                    settings.Configuration = element;
                    break;

                default:
                    throw new SettingsException(
                              string.Format(
                                  CultureInfo.CurrentCulture,
                                  Resources.Resources.InvalidSettingsXmlElement,
                                  elementName,
                                  reader.Name));
                }
            }
            reader.ReadEndElement();

            return(settings);
        }
Пример #34
0
 //DOC: Documentation Required
 /// <summary>
 ///
 /// </summary>
 public override bool MoveToNextAttribute()
 {
     return(innerReader.MoveToNextAttribute());
 }
Пример #35
0
        private void ReadNode(XmlReader reader, IConfigSection section)
        {
            while (true)
            {
                var remark = "";
                if (reader.NodeType == XmlNodeType.Comment)
                {
                    remark = reader.Value;
                }
                while (reader.NodeType == XmlNodeType.Comment || reader.NodeType == XmlNodeType.Whitespace)
                {
                    reader.Skip();
                }
                if (reader.NodeType != XmlNodeType.Element)
                {
                    break;
                }

                var name = reader.Name;
                var cfg  = section.AddChild(name);
                // 前一行是注释
                if (!remark.IsNullOrEmpty())
                {
                    cfg.Comment = remark;
                }

                // 读取属性值
                if (reader.HasAttributes)
                {
                    reader.MoveToFirstAttribute();
                    do
                    {
                        var cfg2 = cfg.AddChild(reader.Name);
                        cfg2.Value = reader.Value;
                    } while (reader.MoveToNextAttribute());
                }
                else
                {
                    reader.ReadStartElement();
                }
                while (reader.NodeType == XmlNodeType.Whitespace)
                {
                    reader.Skip();
                }

                // 遇到下一层节点
                if (reader.NodeType == XmlNodeType.Element || reader.NodeType == XmlNodeType.Comment)
                {
                    ReadNode(reader, cfg);
                }
                else if (reader.NodeType == XmlNodeType.Text)
                {
                    cfg.Value = reader.ReadContentAsString();
                }

                if (reader.NodeType == XmlNodeType.Attribute)
                {
                    reader.Read();
                }
                if (reader.NodeType == XmlNodeType.EndElement)
                {
                    reader.ReadEndElement();
                }
                while (reader.NodeType == XmlNodeType.Whitespace)
                {
                    reader.Skip();
                }
            }
        }
Пример #36
0
 internal void ReadContentFrom(XmlReader r)
 {
     if (r.ReadState != ReadState.Interactive) throw new InvalidOperationException(SR.InvalidOperation_ExpectedInteractive);
     XContainer c = this;
     NamespaceCache eCache = new NamespaceCache();
     NamespaceCache aCache = new NamespaceCache();
     do
     {
         switch (r.NodeType)
         {
             case XmlNodeType.Element:
                 XElement e = new XElement(eCache.Get(r.NamespaceURI).GetName(r.LocalName));
                 if (r.MoveToFirstAttribute())
                 {
                     do
                     {
                         e.AppendAttributeSkipNotify(new XAttribute(aCache.Get(r.Prefix.Length == 0 ? string.Empty : r.NamespaceURI).GetName(r.LocalName), r.Value));
                     } while (r.MoveToNextAttribute());
                     r.MoveToElement();
                 }
                 c.AddNodeSkipNotify(e);
                 if (!r.IsEmptyElement)
                 {
                     c = e;
                 }
                 break;
             case XmlNodeType.EndElement:
                 if (c.content == null)
                 {
                     c.content = string.Empty;
                 }
                 if (c == this) return;
                 c = c.parent;
                 break;
             case XmlNodeType.Text:
             case XmlNodeType.SignificantWhitespace:
             case XmlNodeType.Whitespace:
                 c.AddStringSkipNotify(r.Value);
                 break;
             case XmlNodeType.CDATA:
                 c.AddNodeSkipNotify(new XCData(r.Value));
                 break;
             case XmlNodeType.Comment:
                 c.AddNodeSkipNotify(new XComment(r.Value));
                 break;
             case XmlNodeType.ProcessingInstruction:
                 c.AddNodeSkipNotify(new XProcessingInstruction(r.Name, r.Value));
                 break;
             case XmlNodeType.DocumentType:
                 c.AddNodeSkipNotify(new XDocumentType(r.LocalName, r.GetAttribute("PUBLIC"), r.GetAttribute("SYSTEM"), r.Value));
                 break;
             case XmlNodeType.EntityReference:
                 if (!r.CanResolveEntity) throw new InvalidOperationException(SR.InvalidOperation_UnresolvedEntityReference);
                 r.ResolveEntity();
                 break;
             case XmlNodeType.EndEntity:
                 break;
             default:
                 throw new InvalidOperationException(SR.Format(SR.InvalidOperation_UnexpectedNodeType, r.NodeType));
         }
     } while (r.Read());
 }
Пример #37
0
        public static void HandleBuilding(XmlReader reader, CityGml2GO cityGml2Go)
        {
            var buildingName = "";

            while (reader.MoveToNextAttribute())
            {
                if (reader.LocalName == "id")
                {
                    buildingName = reader.Value;
                }
            }

            var buildingGo         = new GameObject(string.IsNullOrEmpty(buildingName) ? "Building" : buildingName);
            var buildingProperties = buildingGo.AddComponent <Scripts.BuildingProperties>();
            var semanticType       = buildingGo.AddComponent <SemanticType>();

            buildingGo.transform.SetParent(cityGml2Go.Parent.transform);

            while (reader.Read())
            {
                if (reader.NodeType == XmlNodeType.Element && reader.LocalName == "X3DMaterial")
                {
                    MaterialHandler.HandleMaterial(reader, cityGml2Go);
                }

                if (reader.NodeType == XmlNodeType.Element && reader.LocalName == "ParameterizedTexture")
                {
                    TextureHandler.HandleTexture(reader, cityGml2Go);
                }

                if (reader.NodeType == XmlNodeType.Element && reader.LocalName == "Polygon")
                {
                    var polyGo = PolygonHandler.PolyToMesh(reader, buildingName, cityGml2Go, semanticType);
                    if (polyGo != null)
                    {
                        polyGo.transform.SetParent(buildingGo.transform);
                    }
                }

                if (cityGml2Go.ShowCurves)
                {
                    if (reader.NodeType == XmlNodeType.Element && reader.LocalName == "MultiCurve")
                    {
                        MultiCurveHandler.HandleMultiCurve(reader, buildingGo, semanticType, cityGml2Go);
                    }
                }

                if (cityGml2Go.Semantics)
                {
                    if (reader.NodeType == XmlNodeType.Element && cityGml2Go.SemanticSurfaces.Any(x => x == reader.LocalName))
                    {
                        semanticType.Name = reader.LocalName;
                        reader.MoveToFirstAttribute();
                        if (reader.LocalName == "id")
                        {
                            semanticType.Id = reader.Value;
                        }
                        else
                        {
                            while (reader.MoveToNextAttribute())
                            {
                                semanticType.Id = reader.Value;
                            }
                        }
                    }
                }

                BuildingPropertiesHandler.HandleBuildingProperties(reader, buildingProperties);

                if (reader.NodeType == XmlNodeType.EndElement && reader.LocalName == "Building")
                {
                    break;
                }
            }

            Object.Destroy(semanticType);
        }
Пример #38
0
    // Read and extract into Element class each attribut of node name "element"
    Element check_attribute_element(XmlReader xml_reader, Element element)
    {
        if (xml_reader.HasAttributes)
        {
            while (xml_reader.MoveToNextAttribute() != false)
            {
                string prefab_name = "";

                if ((prefab_name = xml_reader.GetAttribute("prefab")) != null)
                {
                    if (Resources.Load(prefab_name) != null)
                        element.prefab = Resources.Load(prefab_name) as GameObject;
                }
            }
        }
        return element;
    }
Пример #39
0
        /// <summary>
        /// Parses a Fortify Result element from an <see cref="XmlReader"/>.
        /// </summary>
        /// <param name="xmlReader">The <see cref="XmlReader"/> from which an element containing a Fortify result shall be
        /// consumed. When this method returns, this <see cref="XmlReader"/> is positioned on the following element.</param>
        /// <param name="strings">Strings used in processing a Fortify report.</param>
        /// <returns>A <see cref="FortifyIssue"/> containing data from the node on which <paramref name="xmlReader"/> was
        /// placed when this method was called.</returns>
        public static FortifyIssue Parse(XmlReader xmlReader, FortifyStrings strings)
        {
            //<xs:element name="Result">
            //    <xs:complexType>
            //        <xs:sequence>
            //            <!-- Result Description -->
            //            <xs:element name="Category" type="xs:string" minOccurs="1" maxOccurs="1"/>
            //            <xs:element name="Folder" type="xs:string" minOccurs="1" maxOccurs="1"/>
            //            <xs:element name="Kingdom" type="xs:string" minOccurs="1" maxOccurs="1"/>
            //            <xs:element name="Abstract" type="xs:string" minOccurs="0" maxOccurs="1"/>
            //            <xs:element name="AbstractCustom" type="xs:string" minOccurs="0" maxOccurs="1"/>
            //            <xs:element name="Friority" type="xs:string" minOccurs="0" maxOccurs="1"/>
            //            <!-- custom tags including Analysis -->
            //            <xs:element name="Tag" minOccurs="0" maxOccurs="unbounded">
            //                <xs:complexType>
            //                    <xs:sequence>
            //                        <xs:element name="Name" type="xs:string" minOccurs="1" maxOccurs="1"/>
            //                        <xs:element name="Value" type="xs:string" minOccurs="1" maxOccurs="1"/>
            //                    </xs:sequence>
            //                </xs:complexType>
            //            </xs:element>
            //            <xs:element name="Comment" minOccurs="0" maxOccurs="unbounded">
            //                <xs:complexType>
            //                    <xs:sequence>
            //                        <xs:element name="UserInfo" type="xs:string" minOccurs="1" maxOccurs="1"/>
            //                        <xs:element name="Comment" type="xs:string" minOccurs="1" maxOccurs="1"/>
            //                    </xs:sequence>
            //                </xs:complexType>
            //            </xs:element>
            //            <!-- primary or sink -->
            //            <xs:element name="Primary" type="PathElement" minOccurs="1" maxOccurs="1"/>
            //            <!-- source -->
            //            <xs:element name="Source" type="PathElement" minOccurs="0" maxOccurs="1"/>
            //            <xs:element name="TraceDiagramPath" type="xs:string" minOccurs="0" maxOccurs="1"/>
            //            <!-- optional external category (i.e. STIG) -->
            //            <xs:element name="ExternalCategory" minOccurs="0" maxOccurs="1">
            //                <xs:complexType>
            //                    <xs:simpleContent>
            //                        <xs:extension base="xs:string">
            //                            <xs:attribute name="type" type="xs:string" use="required"/>
            //                        </xs:extension>
            //                    </xs:simpleContent>
            //                </xs:complexType>
            //            </xs:element>
            //        </xs:sequence>
            //        <xs:attribute name="iid" type="xs:string" use="optional"/>
            //        <xs:attribute name="ruleID" type="xs:string" use="optional"/>
            //    </xs:complexType>
            //</xs:element>
            if (!xmlReader.IsStartElement(strings.Issue))
            {
                throw xmlReader.CreateException(ConverterResources.FortifyNotValidResult);
            }

            string iid    = null;
            string ruleId = null;

            while (xmlReader.MoveToNextAttribute())
            {
                string name = xmlReader.LocalName;
                if (Ref.Equal(name, strings.Iid))
                {
                    iid = xmlReader.Value;
                }
                else if (Ref.Equal(name, strings.RuleId))
                {
                    ruleId = xmlReader.Value;
                }
            }

            xmlReader.MoveToElement();
            xmlReader.Read(); // reads start element

            string category = xmlReader.ReadElementContentAsString(strings.Category, String.Empty);

            xmlReader.IgnoreElement(strings.Folder, IgnoreOptions.Required);
            string kingdom        = xmlReader.ReadElementContentAsString(strings.Kingdom, String.Empty);
            string abstract_      = xmlReader.ReadOptionalElementContentAsString(strings.Abstract);
            string abstractCustom = xmlReader.ReadOptionalElementContentAsString(strings.AbstractCustom);
            string friority       = xmlReader.ReadOptionalElementContentAsString(strings.Friority);

            xmlReader.IgnoreElement(strings.Tag, IgnoreOptions.Optional | IgnoreOptions.Multiple);
            xmlReader.IgnoreElement(strings.Comment, IgnoreOptions.Optional | IgnoreOptions.Multiple);
            FortifyPathElement primary = FortifyPathElement.Parse(xmlReader, strings);
            FortifyPathElement source;

            if (xmlReader.NodeType == XmlNodeType.Element && Ref.Equal(xmlReader.LocalName, strings.Source))
            {
                source = FortifyPathElement.Parse(xmlReader, strings);
            }
            else
            {
                source = null;
            }

            xmlReader.IgnoreElement(strings.TraceDiagramPath, IgnoreOptions.Optional);
            ImmutableArray <int> cweIds = ImmutableArray <int> .Empty;

            if (xmlReader.NodeType == XmlNodeType.Element && Ref.Equal(xmlReader.LocalName, strings.ExternalCategory))
            {
                if (xmlReader.GetAttribute(strings.Type) == "CWE")
                {
                    cweIds = ParseCweIds(xmlReader.ReadElementContentAsString());
                }
                else
                {
                    xmlReader.Skip();
                }
            }

            xmlReader.ReadEndElement(); // </Result>

            return(new FortifyIssue(ruleId, iid, category, kingdom, abstract_, abstractCustom, friority, primary, source, cweIds));
        }
Пример #40
0
    /// <summary>
    /// Reads a specific data tag from the xml document.
    /// </summary>
    /// <param name='reader'>
    /// Reader.
    /// </param>
    private void ReadData(XmlReader reader)
    {
        //If these values are not being set,
        //something is wrong.
        string key = "ERROR";

        string value = "ERROR";

        if (reader.HasAttributes)
        {
            while (reader.MoveToNextAttribute())
            {
                if (reader.Name == "name")
                {
                    key = reader.Value;
                }
            }
        }

        //Move back to the element
        reader.MoveToElement();

        //Read the child nodes
        if (reader.ReadToDescendant("value"))
        {
            do
            {
                value = reader.ReadString();
            }
            while (reader.ReadToNextSibling("value"));
        }

        //Add the raw values to the dictionary
        textDataBase.Add(key, value);

        //Add the localized parsed values to the localizedObjectDataBase
        LocalizedObject newLocalizedObject = new LocalizedObject();
        newLocalizedObject.ObjectType = LocalizedObject.GetLocalizedObjectType(key);
        newLocalizedObject.TextValue = value;
        localizedObjectDataBase.Add(LocalizedObject.GetCleanKey(key,newLocalizedObject.ObjectType), newLocalizedObject);
    }
Пример #41
0
 public override bool MoveToNextAttribute()
 {
     return(_tr.MoveToNextAttribute());
 }