// 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()); } }
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(); } }
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); } }
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(); }
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(); }
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(); } }
/// <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; }
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); }
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(); }
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(); }
/// <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); }
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; }
// 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); }
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(); }
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); }
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; } } }
public uint Read(XmlReader reader) { return(CommonUtils.ToUInt32(reader.ReadElementString())); }
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 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; }
/// <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(); }
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; } } }
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(); } }
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); } }
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 (); }
public override string ReadElementString() { return(_innerReader.ReadElementString()); }
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; }
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); }
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); }
/// <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; }
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 { } } } }
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; }
private string ReadStringRaw(XmlReader xr) { m_bReadNextNode = false; // ReadElementString skips end tag return(xr.ReadElementString()); }
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; }
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()); } } }
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; }
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); } }
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); }
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(); }
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; } }
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; } } }
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); } }