Exemplo n.º 1
0
        // TwoWayRequest: Accept two integer values, return their sum
        public byte[] TwoWayRequest(WsWsaHeader header, XmlReader reader)
        {
            try
            {
                // Find beginning of request
                reader.ReadStartElement("TwoWayRequest", SimpleServiceNamespaceUri);

                // Find the values to be added
                int X = Convert.ToInt32(reader.ReadElementString("X", SimpleServiceNamespaceUri));
                int Y = Convert.ToInt32(reader.ReadElementString("Y", SimpleServiceNamespaceUri));

                Log.Comment("");
                Log.Comment("X = " + X.ToString() + " Y = " + Y.ToString());
                Log.Comment(X.ToString() + " + " + Y.ToString() + " = " + ((int)(X + Y)).ToString());
                Log.Comment("");

                // Return the response
                return TwoWayResponse(header, X + Y);
            }
            catch (Exception e)
            {
                // Something went wrong 
                throw new WsFaultException(header, WsFaultType.XmlException, e.ToString());
            }
        }
Exemplo n.º 2
0
		public void ReadXml(XmlReader reader)
		{
			reader.MoveToContent();
			var empty = reader.IsEmptyElement;
			reader.ReadStartElement();
			if (!empty)
			{
				while (reader.MoveToContent() == XmlNodeType.Element)
				{
					if (reader.Name == @"ProductName" && !reader.IsEmptyElement)
					{
						ProductName = reader.ReadElementString();
					}
					else if (reader.Name == @"GlyphColor" && !reader.IsEmptyElement)
					{
						GlyphColor = ParseColor(reader.ReadElementString());
					}
					else
					{
						// consume the bad element and skip to next sibling or the parent end element tag
						reader.ReadOuterXml();
					}
				}
				reader.MoveToContent();
				reader.ReadEndElement();
			}
		}
Exemplo n.º 3
0
 public void ReadXml(XmlReader r)
 {
     r.Read(); // move past container
     r.ReadStartElement("dictionary");
     while (r.NodeType != XmlNodeType.EndElement) {
         r.ReadStartElement("item", NS);
         string key = r.ReadElementString("key", NS);
         string value = r.ReadElementString("value", NS);
         r.ReadEndElement();
         r.MoveToContent();
         dictionary.Add(key, value);
     }
 }
Exemplo n.º 4
0
		 void IXmlSerializable.ReadXml(XmlReader r)
		{
			r.MoveToContent();
			r.ReadStartElement("Employee");
			
			 r.ReadStartElement("Name");
			 FirstName = r.ReadElementString("First", ns);
			 LastName = r.ReadElementString("Last", ns);
			r.ReadEndElement();
			r.MoveToContent();
			 ID = Int32.Parse(r.ReadElementString("ID", ns));
			 r.ReadEndElement();
			 
		}
		void IXmlSerializable.ReadXml(XmlReader reader)
		{
			reader.Read();
			reader.ReadStartElement("dictionary");
			while (reader.NodeType != XmlNodeType.EndElement)
			{
				reader.ReadStartElement("item");
				string key = reader.ReadElementString("key");
				string value = reader.ReadElementString("value");
				reader.ReadEndElement();
				reader.MoveToContent();
				dictionary.Add(key, value);
			}
			reader.ReadEndElement();
		}
Exemplo n.º 6
0
        void AddString(XmlReader reader, Hashtable strings)
        {
            string key = reader.Name;

            if (strings.ContainsKey(key))
                throw new InvalidDataException("Already contains key (" + key + ")");

            reader.Read();

            while (reader.IsStartElement())
            {
                string name = reader.Name;
                string value = reader.ReadElementString();

                if (string.IsNullOrEmpty(value))
                    continue;

                if (name == culture.Name)
                    strings.Add(key, value);

                if (name == "default" && culture.Equals(CultureInfo.InvariantCulture))
                    strings.Add(key, value);
            }

            reader.ReadEndElement();
        }
Exemplo n.º 7
0
        private void ReadElement(XmlReader reader, Bag parent) {
            var name = XmlConvert.DecodeName(reader.LocalName);
            var type = reader["type"];

            // is it a value node ? i.e. type=""
            if (type != null) {
                if (type == "Array") {
                    // go to first item
                    parent.SetMember(name, ReadArray(reader));
                    reader.Read();
                }
                else {
                    var typeCode = (TypeCode)Enum.Parse(typeof(TypeCode), type);
                    var value = SConvert.XmlDecode(typeCode, reader.ReadElementString());
                    parent.SetMember(name, value);
                }
            }
            else {
                var grappe = new Bag();
                reader.Read();
                parent.SetMember(name, grappe);
                while (reader.MoveToContent() == XmlNodeType.Element) {
                    ReadElement(reader, grappe);
                }

                reader.Read();
            }
        }
Exemplo n.º 8
0
 /// <summary>Reads the Elo from an xml writer.</summary>
 /// <remarks>
 /// Uses the string parse function of Elo.
 /// </remarks>
 /// <param name="reader">An xml reader.</param>
 void IXmlSerializable.ReadXml(XmlReader reader)
 {
     var s = reader.ReadElementString();
     BotInfo info;
     TryParse(s, out info);
     m_Name = info.m_Name;
     m_Version = info.m_Version;
     m_Inactive = info.m_Inactive;
 }
Exemplo n.º 9
0
        private void readBuilding(XmlReader inReader)
        {
            Building building = new Building();

            while (inReader.Read())
            {
                if (inReader.NodeType == XmlNodeType.Element)
                {
                    switch (inReader.Name.ToLower())
                    {
                        case "name":
                            building.Name = inReader.ReadElementString();
                            break;
                        case "identifier":
                            building.Identifier = inReader.ReadElementString();
                            break;
                        case "type":
                            switch (inReader.ReadElementString().ToLower())
                            {
                                case "pollutionreducer":
                                    building.Type = BuildingTypes.PollutionReducer;
                                    break;
                                case "powerplant":
                                    building.Type = BuildingTypes.Powerplant;
                                    break;
                                case "house":
                                    building.Type = BuildingTypes.House;
                                    break;
                                case "storage":
                                    building.Type = BuildingTypes.Storage;
                                    break;
                            }
                            break;
                        case "properties":
                            readProperties(inReader.ReadSubtree(), building.Values);
                            break;
                        case "active":
                            readActive(inReader.ReadSubtree(), building.Values);
                            break;
                        case "passive":
                            readPassive(inReader.ReadSubtree(), building.Values);
                            break;
                        case "construct":
                            readConstruct(inReader.ReadSubtree(), building.Values);
                            break;
                        case "upgrades":
                            readUpgrades(inReader.ReadSubtree(), building);
                            break;
                    }
                }
            }

            if (building.isValid()) Buildings.Add(building);
        }
Exemplo n.º 10
0
        internal Person(XmlReader rdr)
        {
            rdr.ReadStartElement("person");
            this.Id = int.Parse(rdr.ReadElementString("id"));
            this.FirstName = rdr.ReadElementString("first_name");
            this.LastName = rdr.ReadElementString("last_name");
            //Skipping Image Fields
            rdr.ReadToFollowing("title");
            this.Title = rdr.ReadElementString("title");
            this.Company = rdr.ReadElementString("company");

            int companyId;
            if (int.TryParse(rdr.ReadElementString("company_id"), out companyId))
                this.CompanyId = companyId;

            this.Tags = Tag.BuildList(rdr);
            this.Locations = Location.BuildList(rdr);
            this.MegaComments = MegaComment.BuildList(rdr);
            this.Notes = rdr.ReadElementString("notes");
            this.CreatedAt = rdr.ReadElementString("created_at").FromBatchBookFormat();
            this.UpdatedAt = rdr.ReadElementString("updated_at").FromBatchBookFormat();
            rdr.ReadEndElement();
        }
Exemplo n.º 11
0
        public byte[] OneWay(WsWsaHeader header, XmlReader reader)
        {
             try
            {
                // Find beginning of request
                reader.ReadStartElement("OneWay", SimpleServiceNamespaceUri);

                // Find the integer value
                int number = Convert.ToInt32(reader.ReadElementString("Param", SimpleServiceNamespaceUri));

                Log.Comment("");
                Log.Comment("Integer = " + number.ToString());
                Log.Comment("");

                return new byte[0];     // Empty response
            }
            catch (Exception e)
            {
                // Something went wrong
                throw new WsFaultException(header, WsFaultType.XmlException, e.ToString());
            }
        }
 private static String ReadMethodName(XmlReader reader)
 {
     RecursiveTypeSerializer.CheckTag(reader, XmlRpcSpec.METHOD_NAME_TAG);
     return reader.ReadElementString();
 }
Exemplo n.º 13
0
        /// <summary>
        /// Event renew stub.
        /// </summary>
        /// <param name="header">Header object.</param>
        /// <param name="reader">An XmlReader positioned at the begining of the Renew request body element.</param>
        /// <param name="serviceEndpoints">A Collection of serviceEndpoints used to determine what services contain the specified event.</param>
        /// <returns>Byte array containing an Renew response.</returns>
        /// <remarks>This method is used by the stack framework. Do not use this method.</remarks>
        public WsMessage Renew(WsWsaHeader header, XmlReader reader, WsServiceEndpoints serviceEndpoints)
        {
            long newExpiration = 0;
            String eventSinkId = String.Empty;

            // Parse Renew request
            ////////////////////////////
            try
            {
                reader.ReadStartElement("Renew", WsWellKnownUri.WseNamespaceUri);

                if (reader.IsStartElement("Expires", WsWellKnownUri.WseNamespaceUri))
                {
                    newExpiration = new WsDuration(reader.ReadElementString()).DurationInSeconds;

                    if (newExpiration <= 0)
                    {
                        throw new WsFaultException(header, WsFaultType.WseInvalidExpirationTime);
                    }
                }
                else
                {
                    // Never Expires
                    newExpiration = -1;
                }

                eventSinkId = header.Any.GetNodeValue("Identifier", WsWellKnownUri.WseNamespaceUri);

                if (eventSinkId == null)
                {
                    throw new XmlException();
                }
            }
            catch (XmlException e)
            {
                throw new WsFaultException(header, WsFaultType.WseInvalidMessage, e.ToString());
            }

            // Parse urn:uuid from the To address
            string endpointAddress = FixToAddress(header.To);

            // Iterate the list of hosted services at the specified endpoint and renew each subscription
            // with and event source that matches the eventSinkID
            DpwsWseEventSink eventSink;
            bool eventSinkFound = false;

            DpwsHostedService endpoint = (DpwsHostedService)serviceEndpoints[endpointAddress];

            if(endpoint != null)
            {
                if ((eventSink = GetEventSink(endpoint.EventSources, eventSinkId)) != null)
                {
                    eventSinkFound = true;

                    // Update event sink expires time
                    eventSink.Expires = newExpiration;
                }
            }

            // Generate Response
            if (eventSinkFound)
                return GetStatusResponse(header, newExpiration); // It's just like the GetStatus Response
            throw new WsFaultException(header, WsFaultType.WseEventSourceUnableToProcess, "Subscription was not found. ID=" + eventSinkId);
        }
Exemplo n.º 14
0
		private static string GetIcuOptionFromNode(XmlReader reader)
		{
			Debug.Assert(reader.NodeType == XmlNodeType.Element);
			string result;
			switch (reader.Name)
			{
				case "suppress_contractions":
				case "optimize":
					result = String.Format(NewLine + "[{0} {1}]", reader.Name.Replace('_', ' '), reader.ReadElementString());
					break;
				default:
					throw new ApplicationException(String.Format("Invalid LDML collation option element: {0}", reader.Name));
			}
			return result;
		}
 private PlistDictionary LoadDictionaryContents(XmlReader reader, PlistDictionary dict)
 {
     Debug.Assert(reader.NodeType == XmlNodeType.Element && reader.LocalName == "key");
     while (!reader.EOF && reader.NodeType == XmlNodeType.Element)
     {
         string key = reader.ReadElementString();
         while (reader.NodeType != XmlNodeType.Element && reader.Read())
             if (reader.NodeType == XmlNodeType.EndElement)
                 throw new Exception(String.Format("No value found for key {0}", key));
         PlistObjectBase result = LoadFromNode(reader);
         if (result != null)
             dict.Add(key, result);
         reader.ReadToNextSibling("key");
     }
     return dict;
 }
Exemplo n.º 16
0
        // ProbeMatch response stub
        public byte[] Probe(WsWsaHeader header, XmlReader reader)
        {
            // If Adhoc disco is turned off return null. Adhoc disco is optional with a Discovery Proxy
            if (Device.SupressAdhoc == true)
            {
                return(null);
            }

            reader.ReadStartElement("Probe", WsWellKnownUri.WsdNamespaceUri);

            bool match = true;

            if (reader.IsStartElement("Types", WsWellKnownUri.WsdNamespaceUri))
            {
                // Look for specified type, send probe match if any instance of any of the listed types are found
                match = false;
                string[] typesList = reader.ReadElementString().Split(' ');

                int count = typesList.Length;
                for (int i = 0; i < count; i++)
                {
                    string type = typesList[i];
                    // Parse type
                    string namespaceUri, prefix, typeName;
                    int    namespaceIndex = type.IndexOf(':');
                    if (namespaceIndex == -1)
                    {
                        namespaceUri = "";
                        typeName     = type;
                    }
                    else
                    {
                        if (namespaceIndex == type.Length - 1)
                        {
                            throw new XmlException("Probe - Invalid type name: " + type);
                        }

                        prefix       = type.Substring(0, namespaceIndex);
                        namespaceUri = reader.LookupNamespace(prefix);

                        if (namespaceUri == null)
                        {
                            namespaceUri = prefix;
                        }

                        typeName = type.Substring(namespaceIndex + 1);
                    }

                    // Check for the dpws standard type
                    if (namespaceUri == WsWellKnownUri.WsdpNamespaceUri && typeName == "Device")
                    {
                        match = true;
                        break;
                    }

                    // If there is a host check it
                    if (Device.Host != null)
                    {
                        if (Device.Host.ServiceNamespace.NamespaceURI == namespaceUri && Device.Host.ServiceTypeName == typeName)
                        {
                            match = true;
                            break;
                        }
                    }

                    // Check for matching service
                    int servicesCount = Device.HostedServices.Count;
                    DpwsHostedService hostedService;
                    for (i = 0; i < servicesCount; i++)
                    {
                        hostedService = (DpwsHostedService)Device.HostedServices[i];
                        // Skip internal services
                        if (hostedService.ServiceTypeName == "Internal")
                        {
                            continue;
                        }

                        if (hostedService.ServiceNamespace.NamespaceURI == namespaceUri &&
                            hostedService.ServiceTypeName == typeName)
                        {
                            match = true;
                            break;
                        }
                    }
                }
            }

            // For completeness sake
            // We don't care about the rest...
            XmlReaderHelper.SkipAllSiblings(reader);
            reader.ReadEndElement(); // Probe

            if (match == true)
            {
                return(new DpwsDeviceDiscovery().ProbeMatch(header, reader));
            }

            return(null);
        }
Exemplo n.º 17
0
        public void ReadXml(XmlReader reader)
        {
            reader.MoveToContent();

            Rows = int.Parse(reader.GetAttribute("rows"));
            Cols = int.Parse(reader.GetAttribute("cols"));

            reader.ReadStartElement();

            if (Rows > 0 && Cols > 0)
            {
                _asTransposeRef = false;
                _matrix = new double[Rows][];
                for (int i = 0; i < Rows; i++)
                {
                    reader.ReadStartElement("r");
                    _matrix[i] = new double[Cols];
                    for (int j = 0; j < Cols; j++)
                        _matrix[i][j] = double.Parse(reader.ReadElementString("e"));
                    reader.ReadEndElement();
                }
            }
            else
                throw new InvalidOperationException("Invalid matrix size in XML!");

            reader.ReadEndElement();
        }
Exemplo n.º 18
0
        protected bool ReadNode(XmlReader reader, List <Match> matchList, List <Span> spanList, List <Marker> prevMarkerList)
        {
            switch (reader.LocalName)
            {
            case "Delimiters":
                this.Delimiter = reader.ReadElementString();
                return(true);

            case "Property":
                string name  = reader.GetAttribute("name");
                string value = reader.ReadElementString();

                if (!properties.ContainsKey(name))
                {
                    properties [name] = new List <string> ();
                }
                properties [name].Add(value);
                return(true);

            case Match.Node:
                matchList.Add(Match.Read(reader));
                return(true);

            case Span.Node:
            case Span.AltNode:
                spanList.Add(Span.Read(reader));
                return(true);

            case Mono.TextEditor.Highlighting.Keywords.Node:
                Keywords keywords = Mono.TextEditor.Highlighting.Keywords.Read(reader, IgnoreCase);
                this.keywords.Add(keywords);
                foreach (string word in keywords.Words)
                {
                    if (keywords.IgnoreCase)
                    {
                        if (keywordTableIgnoreCase == null)
                        {
                            keywordTableIgnoreCase = new Dictionary <string, Keywords> (StringComparer.InvariantCultureIgnoreCase);
                        }
                        if (keywordTableIgnoreCase.ContainsKey(word))
                        {
                            Console.WriteLine("Error: duplicate keyword " + word);
                            continue;
                        }
                        keywordTableIgnoreCase.Add(word, keywords);
                    }
                    else
                    {
                        if (keywordTable == null)
                        {
                            keywordTable = new Dictionary <string, Keywords> ();
                        }
                        if (keywordTable.ContainsKey(word))
                        {
                            Console.WriteLine("Error: duplicate keyword " + word);
                            continue;
                        }
                        keywordTable.Add(word, keywords);
                    }
                }
                return(true);

            case Marker.PrevMarker:
                prevMarkerList.Add(Marker.Read(reader));
                return(true);
            }
            return(false);
        }
Exemplo n.º 19
0
        public void read_xml()
        {
            XmlReader textreader = XmlReader.Create("C:\\major\\XMLfeature.xml");
            //textReader.Read();
            int    i = 0, j = 0;
            string s1, s2;

            while (textreader.ReadToFollowing("FaceRecognition"))
            {
                textreader.ReadToFollowing("noOfSuspects");
                noOfSuspects = Convert.ToInt32(textreader.ReadInnerXml());



                textreader.ReadToFollowing("noOfImages");
                noOfImages = Convert.ToInt32(textreader.ReadInnerXml());
                //noOfImages = textreader.ReadElementContentAsInt();

                textreader.ReadToFollowing("ImgHeight");
                height = Convert.ToInt32(textreader.ReadInnerXml());



                textreader.ReadToFollowing("ImgWidth");
                width = Convert.ToInt32(textreader.ReadInnerXml());



                int fX, fY;
                textreader.ReadToFollowing("featuresX");
                fX = Convert.ToInt32(textreader.ReadInnerXml());


                textreader.ReadToFollowing("featuresY");
                fY = Convert.ToInt32(textreader.ReadInnerXml());

                int dX = 0, dY = 0;
                textreader.ReadToFollowing("DFLDTransX");
                dX = Convert.ToInt32(textreader.ReadInnerXml());


                textreader.ReadToFollowing("DFLDTransY");
                dY = Convert.ToInt32(textreader.ReadInnerXml());

                DFLD_Trans = new double[dX, dY];

                imagePerClass = new int[noOfSuspects];
                //while ()
                {
                    textreader.ReadToFollowing("Class");
                    while (i < imagePerClass.GetLength(0))
                    {
                        textreader.ReadToFollowing(string.Concat("c", i));
                        imagePerClass[i] = Convert.ToInt32(textreader.ReadInnerXml());
                        i++;
                    }
                }

                i = 0;



                y  = new double[fX, fY];
                s1 = "p0";
                s2 = "f0";
                //while (textreader.ReadToFollowing("features"))
                {
                    textreader.ReadToFollowing("features");
                    i = 0; j = 0;
                    for (i = 0; i < y.GetLength(1); i++)
                    {
                        for (j = 0; j < y.GetLength(0); j++)
                        {
                            s1 = Convert.ToString(i);
                            s2 = Convert.ToString(j);
                            string s3 = string.Concat(string.Concat(string.Concat("f", s1), "f"), s2);
                            //while (textreader.ReadToFollowing(string.Concat(string.Concat(string.Concat("f", Convert.ToString(i))), "f"), Convert.ToString(j)))
                            {
                                textreader.ReadToFollowing(s3);
                                y[j, i] = Convert.ToDouble(textreader.ReadInnerXml());
                            }
                        }
                    }
                    //reader.ReadToFollowing(s1);

                    /*while (i<y.GetLength(1))
                     * //while(textreader.ReadToFollowing(s1))
                     * {
                     *   s1 = string.Concat("p", Convert.ToString(i));
                     *   textreader.ReadToFollowing(s1);
                     *
                     *   while (j<y.GetLength(0))
                     *   {
                     *       textreader.ReadToFollowing(s2);
                     *       s2 = string.Concat("f", Convert.ToString(j));
                     *       y[j, i] = Convert.ToDouble(textreader.ReadElementString());
                     *       j++;
                     *   }
                     *
                     *   j = 0;
                     *   i++;
                     * }*/
                    i = 0;
                }
                i = 0; j = 0;

                //while (textreader.ReadToFollowing("DFLDTrans"))
                {
                    textreader.ReadToFollowing("DFLDTrans");

                    //reader.ReadToFollowing(s1);
                    //while (textreader.ReadToFollowing(s1))
                    {
                        for (i = 0; i < DFLD_Trans.GetLength(0); i++)
                        {
                            s1 = string.Concat("Dx", Convert.ToString(i));
                            textreader.ReadToFollowing(s1);
                            for (j = 0; j < DFLD_Trans.GetLength(1); j++)
                            {
                                s2 = string.Concat("Dy", Convert.ToString(j));
                                //while (textreader.ReadToFollowing(s2))
                                {
                                    textreader.ReadToFollowing(s2);
                                    DFLD_Trans[i, j] = Convert.ToDouble(textreader.ReadElementString());
                                    //j++;
                                }
                                //j = 0;
                                //i++;
                            }
                        }
                    }
                    textreader.Close();
                    i = 0;
                }
            }
        }
Exemplo n.º 20
0
 public uint Read(XmlReader reader)
 {
     return(CommonUtils.ToUInt32(reader.ReadElementString()));
 }
Exemplo n.º 21
0
        private static string GetIcuOptionFromNode(XmlReader reader)
        {
            Debug.Assert(reader.NodeType == XmlNodeType.Element);
            string result;

            switch (reader.Name)
            {
            case "suppress_contractions":
            case "optimize":
                result = String.Format(NewLine + "[{0} {1}]", reader.Name.Replace('_', ' '), reader.ReadElementString());
                break;

            default:
                throw new ApplicationException(String.Format("Invalid LDML collation option element: {0}", reader.Name));
            }
            return(result);
        }
Exemplo n.º 22
0
        private void ParseDataNode(XmlReader reader)
        {
            string name         = reader[ResXResourceWriter.NameStr];
            string typeName     = reader[ResXResourceWriter.TypeStr];
            string mimeTypeName = reader[ResXResourceWriter.MimeTypeStr];

            reader.Read();
            object value = null;

            if (reader.NodeType == XmlNodeType.Element)
            {
                value = reader.ReadElementString();
            }
            else
            {
                value = reader.Value.Trim();
            }

            if (mimeTypeName != null && mimeTypeName.Length > 0)
            {
                if (String.Equals(mimeTypeName, ResXResourceWriter.BinSerializedObjectMimeType) ||
                    String.Equals(mimeTypeName, ResXResourceWriter.Beta2CompatSerializedObjectMimeType) ||
                    String.Equals(mimeTypeName, ResXResourceWriter.CompatBinSerializedObjectMimeType))
                {
                    string text = (string)value;
                    byte[] serializedData;
                    serializedData = FromBase64WrappedString(text);

                    if (binaryFormatter == null)
                    {
                        binaryFormatter        = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
                        binaryFormatter.Binder = new ResXSerializationBinder(typeResolver);
                    }
                    IFormatter formatter = binaryFormatter;
                    if (serializedData != null && serializedData.Length > 0)
                    {
                        value = formatter.Deserialize(new MemoryStream(serializedData));
                        if (value is ResXNullRef)
                        {
                            value = null;
                        }
                    }
                }
                else if (String.Equals(mimeTypeName, ResXResourceWriter.SoapSerializedObjectMimeType) ||
                         String.Equals(mimeTypeName, ResXResourceWriter.CompatSoapSerializedObjectMimeType))
                {
                    string text = (string)value;
                    byte[] serializedData;
                    serializedData = FromBase64WrappedString(text);

                    if (serializedData != null && serializedData.Length > 0)
                    {
                        // Performance : don't inline a new SoapFormatter here.  That will always bring in
                        //               the soap assembly, which we don't want.  Throw this in another
                        //               function so the class doesn't have to get loaded.
                        //
                        IFormatter formatter = CreateSoapFormatter();
                        value = formatter.Deserialize(new MemoryStream(serializedData));
                        if (value is ResXNullRef)
                        {
                            value = null;
                        }
                    }
                }
                else if (String.Equals(mimeTypeName, ResXResourceWriter.ByteArraySerializedObjectMimeType))
                {
                    if (typeName != null && typeName.Length > 0)
                    {
                        Type type = ResolveType(typeName);
                        if (type != null)
                        {
                            TypeConverter tc = TypeDescriptor.GetConverter(type);
                            if (tc.CanConvertFrom(typeof(byte[])))
                            {
                                string text = (string)value;
                                byte[] serializedData;
                                serializedData = FromBase64WrappedString(text);

                                if (serializedData != null)
                                {
                                    value = tc.ConvertFrom(serializedData);
                                }
                            }
                        }
                        else
                        {
                            Debug.Fail("Could not find type for " + typeName);
                            // Throw a TypeLoadException here, don't silently
                            // eat this info.  ResolveType failed, so
                            // Type.GetType should as well.
                            Type.GetType(typeName, true);
                        }
                    }
                }
            }
            else if (typeName != null && typeName.Length > 0)
            {
                Type type = ResolveType(typeName);
                if (type != null)
                {
                    if (type == typeof(ResXNullRef))
                    {
                        value = null;
                    }
                    else if (typeName.IndexOf("System.Byte[]") != -1 && typeName.IndexOf("mscorlib") != -1)
                    {
                        // Handle byte[]'s, which are stored as base-64 encoded strings.
                        // We can't hard-code byte[] type name due to version number
                        // updates & potential whitespace issues with ResX files.
                        value = FromBase64WrappedString((string)value);
                    }
                    else
                    {
                        TypeConverter tc = TypeDescriptor.GetConverter(type);
                        if (tc.CanConvertFrom(typeof(string)))
                        {
                            string text = (string)value;
                            value = tc.ConvertFromInvariantString(text);
                        }
                        else
                        {
                            Debug.WriteLine("Converter for " + type.FullName + " doesn't support string conversion");
                        }
                    }
                }
                else
                {
                    Debug.Fail("Could not find type for " + typeName);
                    // Throw a TypeLoadException for this type which we
                    // couldn't load to include fusion binding info, etc.
                    Type.GetType(typeName, true);
                }
            }
            else
            {
                // if mimeTypeName and typeName are not filled in, the value must be a string
                Debug.Assert(value is string, "Resource entries with no Type or MimeType must be encoded as strings");
            }

            if (name == null)
            {
                throw new ArgumentException(SR.GetString(SR.InvalidResXResourceNoName, value));
            }
            resData[name] = value;
        }
Exemplo n.º 23
0
        /// <summary>
        ///   The read xml.
        /// </summary>
        /// <param name="reader"> The reader. </param>
        public void ReadXml(XmlReader reader)
        {
            this.Name = string.Empty;
            this.parameterValues.Clear();

            if (reader.IsEmptyElement)
            {
                reader.ReadStartElement();
                return;
            }

            reader.ReadStartElement();

            while (reader.NodeType != XmlNodeType.EndElement)
            {
                if (reader.NodeType == XmlNodeType.Element)
                {
                    string elementName = reader.Name;
                    if (elementName == "Name")
                    {
                        this.Name = reader.ReadElementString();
                    }
                    else if (elementName == "Child")
                    {
                        XmlWrapper wrapper = new XmlWrapper();
                        wrapper.ReadXml(reader);
                        this.DecoratorTask = wrapper.Task;
                    }
                    else if (this.taskDescription != null)
                    {
                        // Check if parameter.
                        TaskParameterDescription parameterDescription =
                            this.taskDescription.ParameterDescriptions.Find(desc => desc.ParameterName == elementName);
                        if (parameterDescription != null)
                        {
                            Type type = Type.GetType(parameterDescription.Type);

                            reader.ReadStartElement(parameterDescription.ParameterName);

                            XmlSerializer xmlSerializer = new XmlSerializer(type);
                            object        value         = xmlSerializer.Deserialize(reader);

                            reader.ReadEndElement();

                            this.parameterValues[parameterDescription] = value;
                        }
                        else
                        {
                            reader.Skip();
                        }
                    }
                    else
                    {
                        reader.Skip();
                    }
                }
                else
                {
                    reader.Skip();
                }
            }

            reader.ReadEndElement();
        }
Exemplo n.º 24
0
 public override void ReadXml(XmlReader oXmlReader)
 {
     m_oString = oXmlReader.ReadElementString();
 }
 protected void FromXmlInternal(XmlReader r, List<string> log)
 {
     while(r.Read())
     {
         if (r.NodeType == XmlNodeType.EndElement)
         {
             break;
         }
         if (r.NodeType == XmlNodeType.Whitespace)
         {
             continue;
         }
         switch(r.Name)
         {
             case "TargetFile":
                 targetFile = r.ReadElementString();
                 break;
             case "NewFileName":
                 newFileName = r.ReadElementString();
                 break;
             case "FileType":
                 fileTypeEnum = AssetFileEnumFromCompressedName(r.ReadElementString());
                 break;
             default:
                 log.Add(string.Format("In AssetFile.FromXmlInternal, unknown attribute '{0}'", r.Name));
                 break;
         }
     }
 }
Exemplo n.º 26
0
 public void ReadXml(XmlReader reader)
 {
     reader.MoveToContent();
     name = reader.GetAttribute("name");
     reader.ReadStartElement();
     if (!reader.IsEmptyElement)
     {
         line1 = reader.ReadElementString("line1");
         line2 = reader.ReadElementString("line2");
         reader.ReadEndElement();
     }
 }
Exemplo n.º 27
0
        public bool Load(string filename)
        {
            try
            {
                m_filename = filename;
                bool      retval = false;
                XmlReader xr     = XmlReader.Create(filename);
                xr.ReadStartElement("MachineConfig");
                int ver = int.Parse(xr.ReadElementString("FileVersion"));
                if (ver != FILE_VERSION)
                {
                    return(false);
                }
                m_XDLPRes      = double.Parse(xr.ReadElementString("DLP_X_Res"));
                m_YDLPRes      = double.Parse(xr.ReadElementString("DLP_Y_Res"));
                m_PlatXSize    = double.Parse(xr.ReadElementString("PlatformXSize"));
                m_PlatYSize    = double.Parse(xr.ReadElementString("PlatformYSize"));
                m_PlatZSize    = double.Parse(xr.ReadElementString("PlatformZSize"));
                m_Xpixpermm    = double.Parse(xr.ReadElementString("PixPermmX"));
                m_Ypixpermm    = double.Parse(xr.ReadElementString("PixPermmY"));
                m_XMaxFeedrate = double.Parse(xr.ReadElementString("MaxXFeedRate"));
                m_YMaxFeedrate = double.Parse(xr.ReadElementString("MaxYFeedRate"));
                m_ZMaxFeedrate = double.Parse(xr.ReadElementString("MaxZFeedRate"));
                m_monitorid    = xr.ReadElementString("MonitorID");
                CalcPixPerMM();

                if (m_driverconfig.Load(xr))
                {
                    retval = true;
                }
                xr.ReadEndElement();
                xr.Close();
                return(retval);
            }
            catch (Exception ex)
            {
                DebugLogger.Instance().LogRecord(ex.Message);
                return(false);
            }
        }
Exemplo n.º 28
0
		public void ReadXml (XmlReader reader)
		{
			// Read the element enclosing the object
			reader.ReadStartElement();
			reader.MoveToContent ();

			// Reads the "data" element
			reader.ReadStartElement();
			reader.MoveToContent ();
			while (reader.NodeType != XmlNodeType.EndElement)
			{
				if (reader.NodeType == XmlNodeType.Element)
				{
					string key = reader.LocalName;
					data [key] = reader.ReadElementString ();
				}
				else
					reader.Skip ();
				reader.MoveToContent ();
			}

			reader.ReadEndElement ();
		}
Exemplo n.º 29
0
 public override string ReadElementString()
 {
     return(_innerReader.ReadElementString());
 }
Exemplo n.º 30
0
 private Page ParsePage(XmlReader PageElement)
 {
     Page page = new Page();
     int GotCount = 0;
     while (PageElement.Read())
     {
         switch (PageElement.Name)
         {
             case "title":
                 page.Title = PageElement.ReadElementString();
                 GotCount++;
                 break;
             case "redirect":
                 page.RedirectTo = PageElement.GetAttribute("title");
                 GotCount++;
                 break;
             case "text":
                 page.Text = PageElement.ReadElementString();
                 GotCount++;
                 break;
         }
         if (GotCount == 3) break;
     }
     return page;
 }
Exemplo n.º 31
0
        private void ParseResHeaderNode(XmlReader reader)
        {
            string name = reader[ResXResourceWriter.NameStr];

            if (name != null)
            {
                reader.ReadStartElement();

                // The "1.1" schema requires the correct casing of the strings
                // in the resheader, however the "1.0" schema had a different
                // casing. By checking the Equals first, we should
                // see significant performance improvements.
                //

                if (object.Equals(name, ResXResourceWriter.VersionStr))
                {
                    if (reader.NodeType == XmlNodeType.Element)
                    {
                        resHeaderVersion = reader.ReadElementString();
                    }
                    else
                    {
                        resHeaderVersion = reader.Value.Trim();
                    }
                }
                else if (object.Equals(name, ResXResourceWriter.ResMimeTypeStr))
                {
                    if (reader.NodeType == XmlNodeType.Element)
                    {
                        resHeaderMimeType = reader.ReadElementString();
                    }
                    else
                    {
                        resHeaderMimeType = reader.Value.Trim();
                    }
                }
                else if (object.Equals(name, ResXResourceWriter.ReaderStr))
                {
                    if (reader.NodeType == XmlNodeType.Element)
                    {
                        resHeaderReaderType = reader.ReadElementString();
                    }
                    else
                    {
                        resHeaderReaderType = reader.Value.Trim();
                    }
                }
                else if (object.Equals(name, ResXResourceWriter.WriterStr))
                {
                    if (reader.NodeType == XmlNodeType.Element)
                    {
                        resHeaderWriterType = reader.ReadElementString();
                    }
                    else
                    {
                        resHeaderWriterType = reader.Value.Trim();
                    }
                }
                else
                {
                    switch (name.ToLower(CultureInfo.InvariantCulture))
                    {
                    case ResXResourceWriter.VersionStr:
                        if (reader.NodeType == XmlNodeType.Element)
                        {
                            resHeaderVersion = reader.ReadElementString();
                        }
                        else
                        {
                            resHeaderVersion = reader.Value.Trim();
                        }
                        break;

                    case ResXResourceWriter.ResMimeTypeStr:
                        if (reader.NodeType == XmlNodeType.Element)
                        {
                            resHeaderMimeType = reader.ReadElementString();
                        }
                        else
                        {
                            resHeaderMimeType = reader.Value.Trim();
                        }
                        break;

                    case ResXResourceWriter.ReaderStr:
                        if (reader.NodeType == XmlNodeType.Element)
                        {
                            resHeaderReaderType = reader.ReadElementString();
                        }
                        else
                        {
                            resHeaderReaderType = reader.Value.Trim();
                        }
                        break;

                    case ResXResourceWriter.WriterStr:
                        if (reader.NodeType == XmlNodeType.Element)
                        {
                            resHeaderWriterType = reader.ReadElementString();
                        }
                        else
                        {
                            resHeaderWriterType = reader.Value.Trim();
                        }
                        break;
                    }
                }
            }
        }
 SoapException ReadSoapException(XmlReader reader) {
     XmlQualifiedName faultCode = XmlQualifiedName.Empty;
     string faultString = null;
     string faultActor = null;
     string faultRole = null;
     XmlNode detail = null;
     SoapFaultSubCode subcode = null;
     string lang = null;
     bool soap12 = (reader.NamespaceURI == Soap12.Namespace);
     if (reader.IsEmptyElement) {
         reader.Skip();
     }
     else {
         reader.ReadStartElement();
         reader.MoveToContent();
         int depth = reader.Depth;
         while (reader.NodeType != XmlNodeType.EndElement && reader.NodeType != XmlNodeType.None) {
             if (reader.NamespaceURI == Soap.Namespace || reader.NamespaceURI == Soap12.Namespace || reader.NamespaceURI == null || reader.NamespaceURI.Length == 0) {
                 if (reader.LocalName == Soap.Element.FaultCode || reader.LocalName == Soap12.Element.FaultCode) {
                     if (soap12)
                         faultCode = ReadSoap12FaultCode(reader, out subcode);
                     else
                         faultCode = ReadFaultCode(reader);
                 }
                 else if (reader.LocalName == Soap.Element.FaultString) {
                     lang = reader.GetAttribute(Soap.Attribute.Lang, Soap.XmlNamespace);
                     reader.MoveToElement();
                     faultString = reader.ReadElementString();
                 }
                 else if (reader.LocalName == Soap12.Element.FaultReason) {
                     if (reader.IsEmptyElement)
                         reader.Skip();
                     else {
                         reader.ReadStartElement(); // consume Reason element to get to Text child
                         reader.MoveToContent();
                         while (reader.NodeType != XmlNodeType.EndElement && reader.NodeType != XmlNodeType.None) {
                             if (reader.LocalName == Soap12.Element.FaultReasonText && reader.NamespaceURI == Soap12.Namespace) {
                                 faultString = reader.ReadElementString();
                             }
                             else {
                                 reader.Skip();
                             }
                             reader.MoveToContent();
                         }
                         while (reader.NodeType == XmlNodeType.Whitespace) reader.Skip();
                         if (reader.NodeType == XmlNodeType.None) reader.Skip();
                         else reader.ReadEndElement();
                     }
                 }
                 else if (reader.LocalName == Soap.Element.FaultActor || reader.LocalName == Soap12.Element.FaultNode) {
                     faultActor = reader.ReadElementString();
                 }
                 else if (reader.LocalName == Soap.Element.FaultDetail || reader.LocalName == Soap12.Element.FaultDetail) {
                     detail = new XmlDocument().ReadNode(reader);
                 }
                 else if (reader.LocalName == Soap12.Element.FaultRole) {
                     faultRole = reader.ReadElementString();
                 }
                 else {
                     reader.Skip();
                 }
             }
             else {
                 reader.Skip();
             }
             reader.MoveToContent();
         }
         // Consume soap:Body and soap:Envelope closing tags
         while (reader.Read() && depth < reader.Depth) {
             // Nothing, just read on
         }
         // consume end tag
         if (reader.NodeType == XmlNodeType.EndElement) {
             reader.Read();
         }
     }
     if (detail != null || soap12) // with soap 1.2, can't tell if fault is for header
         return new SoapException(faultString, faultCode, faultActor, faultRole, lang, detail, subcode, null);
     else
         return new SoapHeaderException(faultString, faultCode, faultActor, faultRole, lang, subcode, null);
 }
Exemplo n.º 33
0
    public static PageColor ReadXml(XmlReader reader)
    {
        PageColor pc = new PageColor();

        if (reader.HasAttributes)
        {
            if (!string.IsNullOrEmpty(reader.GetAttribute("type")) && reader.GetAttribute("type") == "enumeration")
            {
                pc.PageColorOptions = (PageColorOptions)Parser.ParseEnum <PageColorOptions>(reader.ReadElementString());
            }
            else
            {
                throw new NotImplementedException();
            }
        }
        else
        {
            throw new NotImplementedException();
        }

        return(pc);
    }
Exemplo n.º 34
0
        /// <summary>
        /// Global eventing Subscribe stub.
        /// </summary>
        /// <param name="header">Header object.</param>
        /// <param name="reader">An XmlReader positioned at the begining of the Subscribe request body element.</param>
        /// <param name="serviceEndpoints">A Collection of serviceEndpoints used to determine what services contain the event source specified in the filter.</param>
        /// <returns>Byte array containing a Subscribe response.</returns>
        internal WsMessage Subscribe(WsWsaHeader header, XmlReader reader, WsServiceEndpoints serviceEndpoints)
        {
            WsMessage msg = null;

            // Parse Subscribe Request
            /////////////////////////////
            DpwsWseEventSink eventSink = new DpwsWseEventSink();
            try
            {
                reader.ReadStartElement("Subscribe", WsWellKnownUri.WseNamespaceUri);

                if (reader.IsStartElement("EndTo", WsWellKnownUri.WseNamespaceUri))
                {
                    eventSink.EndTo = new WsWsaEndpointRef(reader, m_version.AddressingNamespace);
                }

                reader.ReadStartElement("Delivery", WsWellKnownUri.WseNamespaceUri);
                if (reader.IsStartElement("NotifyTo", WsWellKnownUri.WseNamespaceUri))
                {
                    eventSink.NotifyTo = new WsWsaEndpointRef(reader, m_version.AddressingNamespace);
                }
                else
                {
                    throw new WsFaultException(header, WsFaultType.WseDeliverModeRequestedUnavailable);
                }

                reader.ReadEndElement();

                if (reader.IsStartElement("Expires", WsWellKnownUri.WseNamespaceUri))
                {
                    long expires = new WsDuration(reader.ReadElementString()).DurationInSeconds;

                    if (expires > 0)
                    {
                        eventSink.Expires = expires;
                    }
                    else
                    {
                        throw new WsFaultException(header, WsFaultType.WseInvalidExpirationTime);
                    }
                }
                else
                {
                    // Never Expires
                    eventSink.Expires = -1;
                }

                if (reader.IsStartElement("Filter", WsWellKnownUri.WseNamespaceUri))
                {
                    if (reader.MoveToAttribute("Dialect") == false || reader.Value != m_version.WsdpNamespaceUri + "/Action")
                    {
                        throw new WsFaultException(header, WsFaultType.WseFilteringRequestedUnavailable);
                    }

                    reader.MoveToElement();

                    String filters = reader.ReadElementString();

                    if (filters != String.Empty)
                    {
                        eventSink.Filters = filters.Split(' ');
                    }
                }

                XmlReaderHelper.SkipAllSiblings(reader);

                reader.ReadEndElement(); // Subscribe
            }
            catch (XmlException e)
            {
                throw new WsFaultException(header, WsFaultType.WseInvalidMessage, e.ToString());
            }

            // Parse urn:uuid from the To address
            string endpointAddress = FixToAddress(header.To);

            // Build a temporary collection of device services that match the specified endpoint address.
            WsServiceEndpoints matchingServices = new WsServiceEndpoints();
            for (int i = 0; i < serviceEndpoints.Count; ++i)
            {
                if (serviceEndpoints[i].EndpointAddress == endpointAddress)
                    matchingServices.Add(serviceEndpoints[i]);
            }

            // For each service with a matching endpoint and event sources add an event sink to the
            // event source collection
            for (int i = 0; i < matchingServices.Count; ++i)
            {
                DpwsWseEventSources eventSources = ((DpwsHostedService)matchingServices[i]).EventSources;

                // Set the EventSinkID
                eventSink.ID = "urn:uuid:" + Guid.NewGuid().ToString();

                // If subscribing to all event sources
                if (eventSink.Filters == null)
                {
                    int count = eventSources.Count;
                    for (int ii = 0; i < count; i++)
                    {
                        DpwsWseEventSource eventSource = eventSources[ii];
                        eventSink.StartTime = DateTime.Now.Ticks;
                        eventSource.EventSinks.Add(eventSink);
                    }
                }
                else
                {
                    // If subscribing to a specific event based on an event filter.
                    DpwsWseEventSource eventSource;
                    string[] filterList = eventSink.Filters;
                    int length = filterList.Length;
                    for (int ii = 0; i < length; i++)
                    {
                        if ((eventSource = eventSources[filterList[ii]]) != null)
                        {
                            eventSink.StartTime = DateTime.Now.Ticks;
                            eventSource.EventSinks.Add(eventSink);
                        }
                        else
                        {
                            throw new Exception("Event source " + filterList[ii] + " was not found.");
                        }
                    }
                }
            }

            // Generate Response
            //////////////////////////
            using(XmlMemoryWriter xmlWriter = XmlMemoryWriter.Create())
            {
                WsWsaHeader responseHeader = new WsWsaHeader(
                    WsWellKnownUri.WseNamespaceUri + "/SubscribeResponse",  // Action
                    header.MessageID,                                       // RelatesTo
                    header.ReplyTo.Address.AbsoluteUri,                     // To
                    null, null, null);                                      // ReplyTo, From, Any

                msg = new WsMessage(responseHeader, null, WsPrefix.Wse, null, 
                    new WsAppSequence(Device.AppSequence, Device.SequenceID, Device.MessageID));

                WsSoapMessageWriter smw = new WsSoapMessageWriter(m_version);
                smw.WriteSoapMessageStart(xmlWriter, msg);

                // write body
                xmlWriter.WriteStartElement(WsNamespacePrefix.Wse, "SubscribeResponse", null);
                xmlWriter.WriteStartElement(WsNamespacePrefix.Wse, "SubscriptionManager", null);
                xmlWriter.WriteStartElement(WsNamespacePrefix.Wsa, "Address", null);
                // Create a uri. Use the path (by default will be a uuid) for the sub manager endpoint
                Uri subMgrUri = new Uri(((DpwsHostedService)matchingServices[0]).EndpointAddress);
                xmlWriter.WriteString("http://" + Device.IPV4Address + ":" + Device.Port + "/" + subMgrUri.AbsolutePath);
                xmlWriter.WriteEndElement(); // End Address
                xmlWriter.WriteStartElement(WsNamespacePrefix.Wsa, "ReferenceParameters", null);
                xmlWriter.WriteStartElement(WsNamespacePrefix.Wse, "Identifier", null);
                xmlWriter.WriteString(eventSink.ID);
                xmlWriter.WriteEndElement(); // End Identifier
                xmlWriter.WriteEndElement(); // End ReferenceParameters
                xmlWriter.WriteEndElement(); // End SubscriptionManager
                xmlWriter.WriteStartElement(WsNamespacePrefix.Wse, "Expires", null);
                xmlWriter.WriteString(new WsDuration(eventSink.Expires).DurationString);
                xmlWriter.WriteEndElement(); // End Expires
                xmlWriter.WriteEndElement(); // End SubscribeResponse

                smw.WriteSoapMessageEnd(xmlWriter);

                // Return stream buffer
                msg.Body = xmlWriter.ToArray();
            }

            return msg;
        }
Exemplo n.º 35
0
        public void ReadXml(XmlReader reader)
        {
            if (reader == null)
            {
                throw new ArgumentNullException("reader");
            }
            ArrayList           list    = null;
            XmlValidatingReader reader2 = null;

            try
            {
                if (!this.IsSynchronized)
                {
                    if (this._reading)
                    {
                        return;
                    }
                    Monitor.TryEnter(this.SyncRoot);
                }
                if (this._reading)
                {
                    return;
                }
                this._reading = true;
                if (!(reader is XmlValidatingReader))
                {
                    reader2 = new XmlValidatingReader(reader);
                    XmlSchemaUtil.AppendSchema(reader2, this.GetSchema());
                }
                string section = string.Empty;
                string key     = string.Empty;
                list = new ArrayList();
                while (reader.Read())
                {
                    if (reader.NodeType == XmlNodeType.Element)
                    {
                        switch (reader.Name)
                        {
                        case "section":
                            section = reader.GetAttribute("name");
                            break;

                        case "key":
                            key = reader.GetAttribute("name");
                            if ((section != string.Empty) && (key != string.Empty))
                            {
                                if (reader.IsEmptyElement)
                                {
                                    list.Add(new SettingItem(section, key, string.Empty));
                                }
                                else
                                {
                                    list.Add(new SettingItem(section, key, reader.ReadElementString()));
                                }
                            }
                            break;
                        }
                    }
                }
            }
            finally
            {
                if (!(reader is XmlValidatingReader) && (reader2 != null))
                {
                    try
                    {
                        reader2.Close();
                    }
                    catch
                    {
                    }
                    reader2 = null;
                }
                if (!this.IsSynchronized)
                {
                    Monitor.Exit(this.SyncRoot);
                }
                this._reading = false;
            }
            if (list.Count > 0)
            {
                for (int i = 0; i < list.Count; i++)
                {
                    try
                    {
                        SettingItem item = (SettingItem)list[i];
                        this.SetValue(item.Section, item.Key, item.Value);
                    }
                    catch
                    {
                    }
                }
            }
        }
Exemplo n.º 36
0
        void IXmlSerializable.ReadXml(XmlReader r)
        {
            byte[] value = null;

            string isNull = r.GetAttribute("nil", XmlSchema.InstanceNamespace);

            if (isNull != null && XmlConvert.ToBoolean(isNull))
            {
                // Read the next value.
                r.ReadElementString();
                SetNull();
            }
            else
            {
                string base64 = r.ReadElementString();
                if (base64 == null)
                {
                    value = Array.Empty<byte>();
                }
                else
                {
                    base64 = base64.Trim();
                    if (base64.Length == 0)
                        value = Array.Empty<byte>();
                    else
                        value = Convert.FromBase64String(base64);
                }
            }

            SetBuffer(value);
        }
 public virtual WebPart ImportWebPart(XmlReader reader, out string errorMessage)
 {
     WebPart part2;
     this.Personalization.EnsureEnabled(true);
     if (reader == null)
     {
         throw new ArgumentNullException("reader");
     }
     bool flag = false;
     if (this.UsePermitOnly)
     {
         this.MinimalPermissionSet.PermitOnly();
         flag = true;
     }
     string str = string.Empty;
     try
     {
         try
         {
             Type type;
             IDictionary personalizablePropertyEntries;
             reader.MoveToContent();
             reader.ReadStartElement("webParts");
             ImportSkipTo(reader, "webPart");
             string attribute = reader.GetAttribute("xmlns");
             if (string.IsNullOrEmpty(attribute))
             {
                 errorMessage = System.Web.SR.GetString("WebPart_ImportErrorNoVersion");
                 return null;
             }
             if (!string.Equals(attribute, "http://schemas.microsoft.com/WebPart/v3", StringComparison.OrdinalIgnoreCase))
             {
                 errorMessage = System.Web.SR.GetString("WebPart_ImportErrorInvalidVersion");
                 return null;
             }
             ImportReadTo(reader, "metaData");
             reader.ReadStartElement("metaData");
             string str3 = null;
             string path = null;
             ImportSkipTo(reader, "type");
             str3 = reader.GetAttribute("name");
             path = reader.GetAttribute("src");
             ImportSkipTo(reader, "importErrorMessage");
             str = reader.ReadElementString();
             WebPart part = null;
             Control control = null;
             try
             {
                 bool isShared = this.Personalization.Scope == PersonalizationScope.Shared;
                 if (!string.IsNullOrEmpty(str3))
                 {
                     if (this.UsePermitOnly)
                     {
                         CodeAccessPermission.RevertPermitOnly();
                         flag = false;
                         this.MediumPermissionSet.PermitOnly();
                         flag = true;
                     }
                     type = WebPartUtil.DeserializeType(str3, true);
                     if (this.UsePermitOnly)
                     {
                         CodeAccessPermission.RevertPermitOnly();
                         flag = false;
                         this.MinimalPermissionSet.PermitOnly();
                         flag = true;
                     }
                     if (!this.IsAuthorized(type, null, null, isShared))
                     {
                         errorMessage = System.Web.SR.GetString("WebPartManager_ForbiddenType");
                         return null;
                     }
                     if (!type.IsSubclassOf(typeof(WebPart)))
                     {
                         if (!type.IsSubclassOf(typeof(Control)))
                         {
                             errorMessage = System.Web.SR.GetString("WebPartManager_TypeMustDeriveFromControl");
                             return null;
                         }
                         control = (Control) this.Internals.CreateObjectFromType(type);
                         control.ID = this.CreateDynamicWebPartID(type);
                         part = this.CreateWebPart(control);
                     }
                     else
                     {
                         part = (WebPart) this.Internals.CreateObjectFromType(type);
                     }
                 }
                 else
                 {
                     if (!this.IsAuthorized(typeof(UserControl), path, null, isShared))
                     {
                         errorMessage = System.Web.SR.GetString("WebPartManager_ForbiddenType");
                         return null;
                     }
                     if (this.UsePermitOnly)
                     {
                         CodeAccessPermission.RevertPermitOnly();
                         flag = false;
                     }
                     control = this.Page.LoadControl(path);
                     type = control.GetType();
                     if (this.UsePermitOnly)
                     {
                         this.MinimalPermissionSet.PermitOnly();
                         flag = true;
                     }
                     control.ID = this.CreateDynamicWebPartID(type);
                     part = this.CreateWebPart(control);
                 }
             }
             catch
             {
                 if (!string.IsNullOrEmpty(str))
                 {
                     errorMessage = str;
                 }
                 else
                 {
                     errorMessage = System.Web.SR.GetString("WebPartManager_ErrorLoadingWebPartType");
                 }
                 return null;
             }
             if (string.IsNullOrEmpty(str))
             {
                 str = System.Web.SR.GetString("WebPart_DefaultImportErrorMessage");
             }
             ImportSkipTo(reader, "data");
             reader.ReadStartElement("data");
             ImportSkipTo(reader, "properties");
             if (!reader.IsEmptyElement)
             {
                 reader.ReadStartElement("properties");
                 if (this.UsePermitOnly)
                 {
                     CodeAccessPermission.RevertPermitOnly();
                     flag = false;
                 }
                 this.ImportIPersonalizable(reader, (control != null) ? control : part);
                 if (this.UsePermitOnly)
                 {
                     this.MinimalPermissionSet.PermitOnly();
                     flag = true;
                 }
             }
             if (control != null)
             {
                 if (!reader.IsEmptyElement)
                 {
                     personalizablePropertyEntries = PersonalizableAttribute.GetPersonalizablePropertyEntries(type);
                     while (reader.Name != "property")
                     {
                         reader.Skip();
                         if (reader.EOF)
                         {
                             errorMessage = null;
                             return part;
                         }
                     }
                     if (this.UsePermitOnly)
                     {
                         CodeAccessPermission.RevertPermitOnly();
                         flag = false;
                     }
                     this.ImportFromReader(personalizablePropertyEntries, control, reader);
                     if (this.UsePermitOnly)
                     {
                         this.MinimalPermissionSet.PermitOnly();
                         flag = true;
                     }
                 }
                 ImportSkipTo(reader, "genericWebPartProperties");
                 reader.ReadStartElement("genericWebPartProperties");
                 if (this.UsePermitOnly)
                 {
                     CodeAccessPermission.RevertPermitOnly();
                     flag = false;
                 }
                 this.ImportIPersonalizable(reader, part);
                 if (this.UsePermitOnly)
                 {
                     this.MinimalPermissionSet.PermitOnly();
                     flag = true;
                 }
                 personalizablePropertyEntries = PersonalizableAttribute.GetPersonalizablePropertyEntries(part.GetType());
             }
             else
             {
                 personalizablePropertyEntries = PersonalizableAttribute.GetPersonalizablePropertyEntries(type);
             }
             while (reader.Name != "property")
             {
                 reader.Skip();
                 if (reader.EOF)
                 {
                     errorMessage = null;
                     return part;
                 }
             }
             if (this.UsePermitOnly)
             {
                 CodeAccessPermission.RevertPermitOnly();
                 flag = false;
             }
             this.ImportFromReader(personalizablePropertyEntries, part, reader);
             if (this.UsePermitOnly)
             {
                 this.MinimalPermissionSet.PermitOnly();
                 flag = true;
             }
             errorMessage = null;
             part2 = part;
         }
         catch (XmlException)
         {
             errorMessage = System.Web.SR.GetString("WebPartManager_ImportInvalidFormat");
             part2 = null;
         }
         catch (Exception exception)
         {
             if ((this.Context != null) && this.Context.IsCustomErrorEnabled)
             {
                 errorMessage = (str.Length != 0) ? str : System.Web.SR.GetString("WebPart_DefaultImportErrorMessage");
             }
             else
             {
                 errorMessage = exception.Message;
             }
             part2 = null;
         }
         finally
         {
             if (flag)
             {
                 CodeAccessPermission.RevertPermitOnly();
             }
         }
     }
     catch
     {
         throw;
     }
     return part2;
 }
Exemplo n.º 38
0
 private string ReadStringRaw(XmlReader xr)
 {
     m_bReadNextNode = false;             // ReadElementString skips end tag
     return(xr.ReadElementString());
 }
Exemplo n.º 39
0
 public override void ReadXml(XmlReader reader)
 {
     // load profile-specific configuration
     KeyDelay = int.Parse(reader.ReadElementString("KeyDelay"), CultureInfo.InvariantCulture);
 }
        protected bool ReadXmlFileInternal(XmlReader r, List<string> log)
        {
            //Debug.Assert(root.LocalName == "AssetDefinition");
            while(r.Read()) {
                if (r.NodeType == XmlNodeType.Whitespace)
                {
                    continue;
                }
                if (r.NodeType == XmlNodeType.EndElement)
                {
                    break;
                }

                switch (r.Name)
                {
                    case "Name":
                        name = r.ReadElementString();
                        break;
                    case "Description":
                        description = r.ReadElementString();
                        break;
                    case "Category":
                        category = r.ReadElementString();
                        break;
                    case "Type":
                        typeEnum = AssetTypeDesc.AssetTypeEnumFromName(r.ReadElementString());
                        break;
                    case "Status":
                        status = AssetTypeDesc.AssetStatusEnumFromName(r.ReadElementString());
                        break;
                    case "Breakage":
                        breakage = r.ReadElementString();
                        break;
                    case "Files":

                        while (r.Read())
                        {
                            if (r.NodeType == XmlNodeType.Whitespace)
                            {
                                continue;
                            }
                            if (r.NodeType == XmlNodeType.EndElement)
                            {
                                break;
                            }
                            switch (r.Name)
                            {
                                case "AssetFile":
                                    files.Add(AssetFile.FromXml(r, log));

                                    break;
                            }
                        }
                        break;
                    case "Properties":
                        while (r.Read())
                        {
                            if (r.NodeType == XmlNodeType.Whitespace)
                            {
                                continue;
                            }
                            if (r.NodeType == XmlNodeType.EndElement)
                            {
                                break;
                            }
                            switch (r.Name)
                            {
                                case "Property":
                                    properties.Add(AssetProperty.FromXml(r));
                                    break;
                            }
                        }
                        break;

                    default:
                        log.Add(string.Format("In AssetDefinition.ReadXmlFileInternal, unknown attribute '{0}'",
                            r.Name));
                        break;
                }
            }
            return true;
        }
Exemplo n.º 41
0
        public void XML2ON(XmlReader xmlReader, double dtdVersion, bool checkMissingArguments)
        {
            string XMLTAG = "";

            // Check the elements arguments of the request
            try
            {
                if ((!xmlReader.IsStartElement(ONXml.XMLTAG_ARGUMENTS)) && (!xmlReader.IsStartElement(ONXml.XMLTAG_FILTERVARIABLES)))
                {
                    throw new ONXMLNavFilterException(null, xmlReader.ToString(), ONXml.XMLTAG_ARGUMENTS, ONXml.XMLTAG_FILTERVARIABLES);
                }
            }
            catch
            {
                throw new ONXMLNavFilterException(null, xmlReader.ToString(), ONXml.XMLTAG_ARGUMENTS, ONXml.XMLTAG_FILTERVARIABLES);
            }

            if (xmlReader.IsEmptyElement)             // Service dont have arguments
            {
                xmlReader.ReadElementString();
                return;
            }

            if (xmlReader.IsStartElement(ONXml.XMLTAG_ARGUMENTS))
            {
                xmlReader.ReadStartElement(ONXml.XMLTAG_ARGUMENTS);
                XMLTAG = ONXml.XMLTAG_ARGUMENT;
            }
            else if (xmlReader.IsStartElement(ONXml.XMLTAG_FILTERVARIABLES))
            {
                xmlReader.ReadStartElement(ONXml.XMLTAG_FILTERVARIABLES);
                XMLTAG = ONXml.XMLTAG_FILTERVARIABLE;
            }

            // While there are arguments to solve ...
            string lName;

            while (xmlReader.IsStartElement(XMLTAG))
            {
                string lXmlType;
                try
                {
                    if (dtdVersion <= 2.0)
                    {
                        lName = xmlReader.GetAttribute(ONXml.XMLATT_NAME_DTD20);
                    }
                    else
                    {
                        lName = xmlReader.GetAttribute(ONXml.XMLATT_NAME);
                    }

                    lXmlType = xmlReader.GetAttribute(ONXml.XMLATT_TYPE);

                    if ((mIdClass == "") && (mIdService == ""))
                    {
                        string             lClass = "";
                        DataTypeEnumerator lType  = new DataTypeEnumerator();
                        if (string.Compare(lXmlType, "autonumeric", true) == 0)
                        {
                            lType = DataTypeEnumerator.Autonumeric;
                        }
                        else if (string.Compare(lXmlType, "int", true) == 0)
                        {
                            lType = DataTypeEnumerator.Int;
                        }
                        else if (string.Compare(lXmlType, "bool", true) == 0)
                        {
                            lType = DataTypeEnumerator.Bool;
                        }
                        else if (string.Compare(lXmlType, "blob", true) == 0)
                        {
                            lType = DataTypeEnumerator.Blob;
                        }
                        else if (string.Compare(lXmlType, "date", true) == 0)
                        {
                            lType = DataTypeEnumerator.Date;
                        }
                        else if (string.Compare(lXmlType, "datetime", true) == 0)
                        {
                            lType = DataTypeEnumerator.DateTime;
                        }
                        else if (string.Compare(lXmlType, "nat", true) == 0)
                        {
                            lType = DataTypeEnumerator.Nat;
                        }
                        else if (string.Compare(lXmlType, "real", true) == 0)
                        {
                            lType = DataTypeEnumerator.Real;
                        }
                        else if (string.Compare(lXmlType, "password", true) == 0)
                        {
                            lType = DataTypeEnumerator.Password;
                        }
                        else if (string.Compare(lXmlType, "string", true) == 0)
                        {
                            lType = DataTypeEnumerator.String;
                        }
                        else if (string.Compare(lXmlType, "text", true) == 0)
                        {
                            lType = DataTypeEnumerator.Text;
                        }
                        else if (string.Compare(lXmlType, "time", true) == 0)
                        {
                            lType = DataTypeEnumerator.Time;
                        }
                        else
                        {
                            lType = DataTypeEnumerator.OID;
                        }

                        xmlReader.ReadStartElement(XMLTAG);
                        if (lType == DataTypeEnumerator.OID)
                        {
                            lClass = xmlReader.GetAttribute("Class");
                        }

                        mArgumentList.Add(lName, new ONArgumentInfo(lName, true, lType, 1000, lClass, "", ""));
                    }
                    else
                    {
                        xmlReader.ReadStartElement(XMLTAG);
                    }
                }
                catch (Exception e)
                {
                    throw new ONXMLStructureException(e, ONXml.XMLATT_NAME);
                }

                try
                {
                    ReadArgument(xmlReader, dtdVersion, lName, lXmlType);
                }
                catch (Exception e)
                {
                    if (e.GetType() == typeof(ONInstanceNotExistException))
                    {
                        throw;
                    }
                    else
                    {
                        throw new ONArgumentException(e, lName);
                    }
                }
                xmlReader.ReadEndElement();                 // Argument
            }

            xmlReader.ReadEndElement();             // Arguments

            // Check the change detection items of the request
            if (xmlReader.IsStartElement(ONXml.XMLTAG_CHANGEDETECTIONITEMS))
            {
                if (xmlReader.IsEmptyElement)                 // Service dont have change detection items
                {
                    xmlReader.ReadElementString();
                    return;
                }

                if (xmlReader.IsStartElement(ONXml.XMLTAG_CHANGEDETECTIONITEMS))
                {
                    xmlReader.ReadStartElement(ONXml.XMLTAG_CHANGEDETECTIONITEMS);
                    XMLTAG = ONXml.XMLTAG_CHANGEDETECTIONITEM;
                }

                // While there are change detection items to solve ...
                while (xmlReader.IsStartElement(XMLTAG))
                {
                    try
                    {
                        lName = xmlReader.GetAttribute(ONXml.XMLATT_NAME);
                        xmlReader.ReadStartElement(XMLTAG);
                    }
                    catch (Exception e)
                    {
                        throw new ONXMLStructureException(e, ONXml.XMLATT_NAME);
                    }

                    try
                    {
                        ReadChangeDetectionItem(xmlReader, dtdVersion, lName);
                    }
                    catch (Exception e)
                    {
                        throw new ONArgumentException(e, lName);
                    }
                    xmlReader.ReadEndElement();                     // ChangeDetectionItem
                }

                xmlReader.ReadEndElement();                 // ChangeDetectionItems
            }

            // Comprobations over the arguments
            foreach (DictionaryEntry lElem in mArgumentList)
            {
                ONArgumentInfo lArg = (ONArgumentInfo)lElem.Value;

                // Check if it is all the arguments
                if (lArg.Value == null)
                {
                    if (checkMissingArguments)
                    {
                        throw new ONMissingArgumentException(null, lArg.IdArgument, lArg.Alias);
                    }
                    else
                    {
                        continue;
                    }
                }

                if (lArg.Value.Value == null && lArg.Null == false)
                {
                    throw new ONNotNullArgumentException(null, mIdService, mIdClass, lArg.IdArgument, mAlias, mClassAlias, lArg.Alias);
                }

                if (lArg.MaxLength > 0)
                {
                    ONString lString = lArg.Value as ONString;
                    //MARTA DEFECT 3766
                    //ONText lText = lArg.Value as ONText;
                    if (((object)lString != null) && (lString.TypedValue != null) && (lString.TypedValue.Length > lArg.MaxLength))
                    {
                        throw new ONMaxLenghtArgumentException(null, lArg.IdArgument, lArg.Alias, lArg.MaxLength.ToString());
                    }
                    //MARTA DEFECT 3766
                    //if (((object) lText != null) && (lText.TypedValue != null) && (lText.TypedValue.Length > lArg.MaxLength))
                    //	throw new ONMaxLenghtArgumentException(null, lArg.IdArgument, lArg.Alias, lArg.MaxLength.ToString());
                }
            }
        }
Exemplo n.º 42
0
		protected override bool ImportXml (XmlReader xr, IWarningLogger log) {
			bool gotdir = false;
			bool gotname = false;
			int depth = xr.Depth;

			while (xr.Depth >= depth) {
				if (xr.NodeType != XmlNodeType.Element) {
					//Console.WriteLine ("skipping {0}: {1} = \"{2}\"", xr.NodeType, xr.Name, xr.Value);
					xr.Read ();
					continue;
				}

				switch (xr.Name) {
				case "result":
					string ignore;

					Result r = Result.ImportXml (xr, out ignore, log);
					if (r == null)
						return true;
					if (!(r is MBDirectory)) {
						log.Warning (3019, "Result embedded in file result is not directory during XML import", null);
						return true;
					}
					dir = (MBDirectory) r;
					gotdir = true;
					break;
				case "name":
					name = xr.ReadElementString ();
					gotname = true;
					break;
				default:
					log.Warning (3019, "Unknown element in file result during XML import", xr.Name);
					xr.Skip ();
					break;
				}
			}

			if (!gotdir) {
				log.Warning (3019, "Did not find directory in file element during XML import", null);
				return true;
			}

			if (!gotname) {
				log.Warning (3019, "Did not find name in file element during XML import", null);
				return true;
			}
			
			return false;
		}
Exemplo n.º 43
0
        public void XML2ONFilterVariables(XmlReader xmlReader, double dtdVersion)
        {
            // Check the filter variables of the request
            try
            {
                if (!xmlReader.IsStartElement(ONXml.XMLTAG_FILTERVARIABLES))
                {
                    throw new ONXMLStructureException(null, ONXml.XMLTAG_FILTERVARIABLES);
                }
            }
            catch
            {
                throw new ONXMLStructureException(null, ONXml.XMLTAG_FILTERVARIABLES);
            }

            if (xmlReader.IsEmptyElement)             // Filter dont have Variables
            {
                xmlReader.ReadElementString();
                return;
            }

            xmlReader.ReadStartElement(ONXml.XMLTAG_FILTERVARIABLES);

            // While there are filters to solve ...
            string lName;

            while (xmlReader.IsStartElement(ONXml.XMLTAG_FILTERVARIABLE))
            {
                lName = xmlReader.GetAttribute(ONXml.XMLATT_NAME);
                string lType = xmlReader.GetAttribute(ONXml.XMLATT_TYPE);
                xmlReader.ReadStartElement(ONXml.XMLTAG_FILTERVARIABLE);

                try
                {
                    ReadArgument(xmlReader, dtdVersion, lName, lType);
                }
                catch (Exception e)
                {
                    throw new ONArgumentException(e, lName);
                }
                xmlReader.ReadEndElement();                 // Filter.Variable
            }

            xmlReader.ReadEndElement();             // Filter.Variables

            // Comprobations over the filters
            foreach (DictionaryEntry lElem in mArgumentList)
            {
                ONArgumentInfo lArg = (ONArgumentInfo)lElem.Value;

                // Check if it is all the filters
                if (lArg.Value == null)
                {
                    throw new ONMissingArgumentException(null, lArg.IdArgument, lArg.Alias);
                }

                if (lArg.Value.Value == null && lArg.Null == false)
                {
                    throw new ONNotNullArgumentException(null, mIdService, mIdClass, lArg.IdArgument, mAlias, mClassAlias, lArg.Alias);
                }

                if (lArg.MaxLength > 0)
                {
                    ONString lString = lArg.Value as ONString;
                    //MARTA DEFECT 3766
                    //ONText lText = lArg.Value as ONText;
                    if (((object)lString != null) && (lString.TypedValue != null) && (lString.TypedValue.Length > lArg.MaxLength))
                    {
                        throw new ONMaxLenghtArgumentException(null, lArg.IdArgument, lArg.Alias, lArg.MaxLength.ToString());
                    }
                    //MARTA DEFECT 3766
                    //if (((object) lText != null) && (lText.TypedValue != null) && (lText.TypedValue.Length > lArg.MaxLength))
                    //	throw new ONMaxLenghtArgumentException(null, lArg.IdArgument, lArg.Alias, lArg.MaxLength.ToString());
                }
            }
        }
 void IXmlSerializable.ReadXml(XmlReader r)
 {
     char[] buffer = null;
     string attribute = r.GetAttribute("nil", "http://www.w3.org/2001/XMLSchema-instance");
     if ((attribute != null) && XmlConvert.ToBoolean(attribute))
     {
         r.ReadElementString();
         this.SetNull();
     }
     else
     {
         buffer = r.ReadElementString().ToCharArray();
         this.SetBuffer(buffer);
     }
 }
Exemplo n.º 45
0
        DEV_INFO ReadXML()
        {
            XmlReader xml     = XmlReader.Create("");
            DEV_INFO  devInfo = new DEV_INFO();

            devInfo.nPort    = 0;
            devInfo.lLoginID = 0;
            devInfo.lID      = 0;

            while (xml.ReadToFollowing("ip"))
            {
                //read the information from XML
                string strIP, strUserName, strPsw, strDevName;
                uint   nPort;
                int    byChanNum = 0, lID = 0;

                uint   bSerialID, nSerPort;
                string szSerIP, szSerialInfo;
                xml = xml.ReadSubtree();


                strIP = xml.ReadElementString("ip2");

                strDevName = xml.ReadElementString("DEVICENAME");

                strUserName = xml.ReadElementString("username");

                nPort = Convert.ToUInt32(xml.ReadElementString("port"));

                strPsw = xml.ReadElementString("pwd");

                byChanNum = Convert.ToInt32(xml.ReadElementString("byChanNum"));

                lID = Convert.ToInt32(xml.ReadElementString("lID"));


                bSerialID = Convert.ToByte(xml.ReadElementString("bSerialID"));

                szSerIP = xml.ReadElementString("szSerIP");

                nSerPort = Convert.ToUInt32(xml.ReadElementString("nSerPort"));

                szSerialInfo = xml.ReadElementString("szSerialInfo");      //新增ddns记录

                devInfo.nTotalChannel = byChanNum;
                devInfo.nPort         = (int)nPort;

                devInfo.bSerialID    = Convert.ToByte(bSerialID);
                devInfo.nSerPort     = (int)nSerPort;
                devInfo.szSerIP      = szSerIP;
                devInfo.szSerialInfo = szSerialInfo;      //新增ddns记录
                devInfo.szDevName    = strDevName;
                devInfo.szUserName   = strUserName;
                devInfo.szPsw        = strPsw;
                devInfo.szIpaddress  = strIP;
                DEV_INFO pDev = new DEV_INFO();
                pDev = devInfo;
                IntPtr ptr = new IntPtr();
                Marshal.StructureToPtr(pDev, ptr, false);
                pDev.lID           = ptr.ToInt32();
                m_devMap[pDev.lID] = pDev;
                String   strName;
                TreeNode node = new  TreeNode();
                node.Text = strDevName;
                for (int i = 0; i < byChanNum; i++)
                {
                    strName = String.Format("CAM {0}", i + 1);
                    node.Nodes.Add(strName);
                }
                DevTree.Nodes.Add(node);
            }
            return(devInfo);
        }
Exemplo n.º 46
0
        void IXmlSerializable.ReadXml(XmlReader reader)
        {
            reader.ReadStartElement();

            reader.ReadStartElement();
            Name = reader.ReadElementString();
            Exists = reader.ReadElementString().DeserializeObject<bool>();
            Size = reader.ReadElementString().DeserializeObject<ulong>();
            SubFilenames = reader.ReadElementString().DeserializeObject<List<string>>();
            InstallTime = reader.ReadElementString().DeserializeObject<DateTime>();
            Properties = reader.ReadElementString().DeserializeObject<SerializableDictionary<string, object>>();
            reader.ReadEndElement();

            reader.ReadEndElement();
        }
Exemplo n.º 47
0
        private Proprietary XmlLoadProprietary(string name)
        {
            string path = PathProprietary(name);

            if (!File.Exists(path))
            {
                return(NullableProprietary);
            }
            XmlReader reader = XmlReader.Create(path);

            Proprietary proprietary = new Proprietary();

            reader.Read();
            if (reader.NodeType == XmlNodeType.XmlDeclaration)
            {
                reader.Read();
            }
            if (reader.IsStartElement())
            {
                reader.Read();
            }

            proprietary.Name          = reader.ReadElementString();
            proprietary.ImageUrl      = reader.ReadElementString();
            proprietary.BackGroundUrl = reader.ReadElementString();
            proprietary.Description   = reader.ReadElementString();
            proprietary.WebSite       = reader.ReadElementString();
            proprietary.Youtube       = reader.ReadElementString();
            proprietary.Facebook      = reader.ReadElementString();
            proprietary.Twitter       = reader.ReadElementString();
            proprietary.Google        = reader.ReadElementString();
            proprietary.Dailymotion   = reader.ReadElementString();
            proprietary.Vimeo         = reader.ReadElementString();
            proprietary.Email         = reader.ReadElementString();

            reader.Close();

            return(proprietary);
        }
 private void ImportFromReader(IDictionary personalizableProperties, Control target, XmlReader reader)
 {
     ImportReadTo(reader, "property");
     bool flag = false;
     if (this.UsePermitOnly)
     {
         this.MinimalPermissionSet.PermitOnly();
         flag = true;
     }
     try
     {
         try
         {
             IDictionary dictionary;
             if (personalizableProperties != null)
             {
                 dictionary = new HybridDictionary();
             }
             else
             {
                 dictionary = new PersonalizationDictionary();
             }
             while (reader.Name == "property")
             {
                 string attribute = reader.GetAttribute("name");
                 string str2 = reader.GetAttribute("type");
                 string a = reader.GetAttribute("scope");
                 bool flag2 = string.Equals(reader.GetAttribute("null"), "true", StringComparison.OrdinalIgnoreCase);
                 if (((attribute == "AuthorizationFilter") || (attribute == "ZoneID")) || (attribute == "ZoneIndex"))
                 {
                     reader.ReadElementString();
                     if (!reader.Read())
                     {
                         throw new XmlException();
                     }
                     goto Label_03AA;
                 }
                 string s = reader.ReadElementString();
                 object obj2 = null;
                 bool flag3 = false;
                 PropertyInfo element = null;
                 if (personalizableProperties != null)
                 {
                     PersonalizablePropertyEntry entry = (PersonalizablePropertyEntry) personalizableProperties[attribute];
                     if (entry != null)
                     {
                         element = entry.PropertyInfo;
                         if ((Attribute.GetCustomAttribute(element, typeof(UrlPropertyAttribute), true) is UrlPropertyAttribute) && CrossSiteScriptingValidation.IsDangerousUrl(s))
                         {
                             throw new InvalidDataException(System.Web.SR.GetString("WebPart_BadUrl", new object[] { s }));
                         }
                     }
                 }
                 Type exportType = null;
                 if (!string.IsNullOrEmpty(str2))
                 {
                     if (this.UsePermitOnly)
                     {
                         CodeAccessPermission.RevertPermitOnly();
                         flag = false;
                         this.MediumPermissionSet.PermitOnly();
                         flag = true;
                     }
                     exportType = GetExportType(str2);
                     if (this.UsePermitOnly)
                     {
                         CodeAccessPermission.RevertPermitOnly();
                         flag = false;
                         this.MinimalPermissionSet.PermitOnly();
                         flag = true;
                     }
                 }
                 if ((element != null) && ((element.PropertyType == exportType) || (exportType == null)))
                 {
                     TypeConverterAttribute attribute2 = Attribute.GetCustomAttribute(element, typeof(TypeConverterAttribute), true) as TypeConverterAttribute;
                     if (attribute2 != null)
                     {
                         if (this.UsePermitOnly)
                         {
                             CodeAccessPermission.RevertPermitOnly();
                             flag = false;
                             this.MediumPermissionSet.PermitOnly();
                             flag = true;
                         }
                         Type type = WebPartUtil.DeserializeType(attribute2.ConverterTypeName, false);
                         if (this.UsePermitOnly)
                         {
                             CodeAccessPermission.RevertPermitOnly();
                             flag = false;
                             this.MinimalPermissionSet.PermitOnly();
                             flag = true;
                         }
                         if ((type != null) && type.IsSubclassOf(typeof(TypeConverter)))
                         {
                             TypeConverter converter = (TypeConverter) this.Internals.CreateObjectFromType(type);
                             if (Util.CanConvertToFrom(converter, typeof(string)))
                             {
                                 if (!flag2)
                                 {
                                     obj2 = converter.ConvertFromInvariantString(s);
                                 }
                                 flag3 = true;
                             }
                         }
                     }
                     if (!flag3)
                     {
                         TypeConverter converter2 = TypeDescriptor.GetConverter(element.PropertyType);
                         if (Util.CanConvertToFrom(converter2, typeof(string)))
                         {
                             if (!flag2)
                             {
                                 obj2 = converter2.ConvertFromInvariantString(s);
                             }
                             flag3 = true;
                         }
                     }
                 }
                 if (!flag3 && (exportType != null))
                 {
                     if (exportType == typeof(string))
                     {
                         if (!flag2)
                         {
                             obj2 = s;
                         }
                         flag3 = true;
                     }
                     else
                     {
                         TypeConverter converter3 = TypeDescriptor.GetConverter(exportType);
                         if (Util.CanConvertToFrom(converter3, typeof(string)))
                         {
                             if (!flag2)
                             {
                                 obj2 = converter3.ConvertFromInvariantString(s);
                             }
                             flag3 = true;
                         }
                     }
                 }
                 if (flag2 && (personalizableProperties == null))
                 {
                     flag3 = true;
                 }
                 if (flag3)
                 {
                     if (personalizableProperties != null)
                     {
                         dictionary.Add(attribute, obj2);
                     }
                     else
                     {
                         PersonalizationScope scope = string.Equals(a, PersonalizationScope.Shared.ToString(), StringComparison.OrdinalIgnoreCase) ? PersonalizationScope.Shared : PersonalizationScope.User;
                         dictionary.Add(attribute, new PersonalizationEntry(obj2, scope));
                     }
                     goto Label_03AA;
                 }
                 throw new HttpException(System.Web.SR.GetString("WebPartManager_ImportInvalidData", new object[] { attribute }));
             Label_035C:
                 if (((reader.EOF || (reader.Name == "genericWebPartProperties")) || (reader.Name == "properties")) || ((reader.Name == "ipersonalizable") && (reader.NodeType == XmlNodeType.EndElement)))
                 {
                     break;
                 }
                 reader.Skip();
             Label_03AA:
                 if (reader.Name != "property")
                 {
                     goto Label_035C;
                 }
             }
             if (personalizableProperties != null)
             {
                 IDictionary unknownProperties = BlobPersonalizationState.SetPersonalizedProperties(target, dictionary);
                 if ((unknownProperties != null) && (unknownProperties.Count > 0))
                 {
                     IVersioningPersonalizable personalizable = target as IVersioningPersonalizable;
                     if (personalizable != null)
                     {
                         personalizable.Load(unknownProperties);
                     }
                 }
             }
             else
             {
                 ((IPersonalizable) target).Load((PersonalizationDictionary) dictionary);
             }
         }
         finally
         {
             if (flag)
             {
                 CodeAccessPermission.RevertPermitOnly();
             }
         }
     }
     catch
     {
         throw;
     }
 }
Exemplo n.º 49
0
        public void ReadXml(XmlReader reader)
        {
            reader.MoveToContent();

            DisplayName = reader.GetAttribute("DisplayName");
            Guid guid;

            Guid.TryParse(reader.GetAttribute("ID"), out guid);
            ID = guid;
            Guid.TryParse(reader.GetAttribute("OriginalInstanceID"), out guid);
            OriginalInstanceID = guid;
            Guid.TryParse(reader.GetAttribute("ParentID"), out guid);
            ParentID = guid;
            Guid.TryParse(reader.GetAttribute("ServerID"), out guid);
            ServerID = guid;

            StateType state;

            Enum.TryParse(reader.GetAttribute("StateType"), out state);
            StateType = state;

            Guid.TryParse(reader.GetAttribute("SessionID"), out guid);
            SessionID = guid;

            while (reader.Read())
            {
                if (reader.IsStartElement("HasError"))
                {
                    var result = reader.ReadElementString("HasError");

                    bool boolean;
                    var  exists = bool.TryParse(result, out boolean);
                    HasError = exists && boolean;
                }

                if (reader.IsStartElement("ErrorMessage"))
                {
                    ErrorMessage = reader.ReadElementString("ErrorMessage");
                }

                if (reader.IsStartElement("Version"))
                {
                    Version = reader.ReadElementString("Version");
                }

                if (reader.IsStartElement("Name"))
                {
                    Name = reader.ReadElementString("Name");
                }

                if (reader.IsStartElement("ActivityType"))
                {
                    var result = reader.ReadElementString("ActivityType");

                    ActivityType activityType;
                    Enum.TryParse(result, out activityType);
                    ActivityType = activityType;
                }

                if (reader.IsStartElement("Duration"))
                {
                    DurationString = reader.ReadElementString("Duration");
                }

                if (reader.IsStartElement("StartTime"))
                {
                    var result = reader.ReadElementString("StartTime");

                    DateTime date;
                    DateTime.TryParse(result, out date);
                    StartTime = date;
                }

                if (reader.IsStartElement("EndTime"))
                {
                    var result = reader.ReadElementString("EndTime");

                    DateTime date;
                    DateTime.TryParse(result, out date);
                    EndTime = date;
                }


                if (reader.IsStartElement("Inputs"))
                {
                    Inputs = new List <IDebugItem>();
                    reader.ReadStartElement();
                    while (reader.MoveToContent() == XmlNodeType.Element && reader.LocalName == "DebugItem")
                    {
                        var item = new DebugItem();
                        item.ReadXml(reader);
                        Inputs.Add(item);
                    }
                    reader.ReadEndElement();
                }

                if (reader.IsStartElement("Outputs"))
                {
                    Outputs = new List <IDebugItem>();
                    reader.ReadStartElement();
                    while (reader.MoveToContent() == XmlNodeType.Element && reader.LocalName == "DebugItem")
                    {
                        var item = new DebugItem();
                        item.ReadXml(reader);
                        Outputs.Add(item);
                    }
                    reader.ReadEndElement();
                }

                if (reader.IsStartElement("ExecutionOrigin"))
                {
                    var result = reader.ReadElementString("ExecutionOrigin");

                    ExecutionOrigin origin;
                    var             exists = Enum.TryParse(result, out origin);
                    if (exists)
                    {
                        ExecutionOrigin = origin;
                    }
                }

                if (reader.IsStartElement("ExecutingUser"))
                {
                    ExecutingUser = reader.ReadElementString("ExecutingUser");
                }

                if (reader.IsStartElement("NumberOfSteps"))
                {
                    int numberOfSteps;
                    var success = int.TryParse(reader.ReadElementString("NumberOfSteps"), out numberOfSteps);
                    if (success)
                    {
                        NumberOfSteps = numberOfSteps;
                    }
                }

                if (reader.NodeType == XmlNodeType.EndElement && reader.Name == "DebugState")
                {
                    reader.ReadEndElement();
                    break;
                }
            }
        }
Exemplo n.º 50
0
		void IXmlSerializable.ReadXml(XmlReader r) {
			char[] value = null;
			
 			string isNull = r.GetAttribute("nil", XmlSchema.InstanceNamespace);
 			
			if (isNull != null && XmlConvert.ToBoolean(isNull)) {
                // VSTFDevDiv# 479603 - SqlTypes read null value infinitely and never read the next value. Fix - Read the next value.
                r.ReadElementString();
                SetNull();
			}
			else {
				value = r.ReadElementString().ToCharArray();
				SetBuffer(value);
			}
		}
        /*This is used to serialize to the GCode post-header info*/
        public bool Load(String filename)
        {
            try
            {
                m_filename = filename;
                LoadGCodes();
                XmlReader xr = (XmlReader)XmlReader.Create(filename);
                xr.ReadStartElement("SliceBuildConfig");
                int ver = int.Parse(xr.ReadElementString("FileVersion"));
                if (ver != FILE_VERSION)
                {
                    return(false); // I may try to implement some backward compatibility here...
                }
                dpmmX             = double.Parse(xr.ReadElementString("DotsPermmX"));
                dpmmY             = double.Parse(xr.ReadElementString("DotsPermmY"));
                xres              = int.Parse(xr.ReadElementString("XResolution"));
                yres              = int.Parse(xr.ReadElementString("YResolution"));
                ZThick            = double.Parse(xr.ReadElementString("SliceHeight"));
                layertime_ms      = int.Parse(xr.ReadElementString("LayerTime"));
                firstlayertime_ms = int.Parse(xr.ReadElementString("FirstLayerTime"));
                blanktime_ms      = int.Parse(xr.ReadElementString("BlankTime"));
                plat_temp         = int.Parse(xr.ReadElementString("PlatformTemp"));
                exportgcode       = bool.Parse(xr.ReadElementString("ExportGCode"));
                exportsvg         = bool.Parse(xr.ReadElementString("ExportSVG"));
                exportimages      = bool.Parse(xr.ReadElementString("ExportImages"));;
                XOffset           = int.Parse(xr.ReadElementString("XOffset"));
                YOffset           = int.Parse(xr.ReadElementString("YOffset"));
                numfirstlayers    = int.Parse(xr.ReadElementString("NumberofBottomLayers"));
                direction         = (eBuildDirection)Enum.Parse(typeof(eBuildDirection), xr.ReadElementString("Direction"));
                liftdistance      = double.Parse(xr.ReadElementString("LiftDistance"));
                slidetiltval      = double.Parse(xr.ReadElementString("SlideTiltValue"));
                antialiasing      = bool.Parse(xr.ReadElementString("AntiAliasing"));
                aaval             = double.Parse(xr.ReadElementString("AntiAliasingValue"));
                liftfeedrate      = double.Parse(xr.ReadElementString("LiftFeedRate"));
                liftretractrate   = double.Parse(xr.ReadElementString("LiftRetractRate"));

                xr.ReadEndElement();
                xr.Close();

                return(true);
            }
            catch (Exception ex)
            {
                DebugLogger.Instance().LogRecord(ex.Message);
                return(false);
            }
        }