private bool _NextToken(XmlReader reader) { while (!reader.EOF && reader.Read() && !reader.IsStartElement()) ; return !reader.EOF; }
internal static void ThrowFaultException(XmlReader reader, WsWsaHeader header) { WsFaultType type = WsFaultType.Exception; string message = ""; string detail = ""; string subcode; reader.ReadStartElement("Body", WsWellKnownUri.SoapNamespaceUri); reader.ReadStartElement("Fault", WsWellKnownUri.SoapNamespaceUri); while (true) { if (reader.IsStartElement("Code", WsWellKnownUri.SoapNamespaceUri)) { reader.ReadStartElement(); //<Code> if (reader.IsStartElement("Value", WsWellKnownUri.SoapNamespaceUri)) { reader.ReadElementString(); } if (reader.IsStartElement("Subcode", WsWellKnownUri.SoapNamespaceUri)) { reader.ReadStartElement(); subcode = reader.ReadElementString("Value", WsWellKnownUri.SoapNamespaceUri); int idx = subcode.IndexOf(':'); if (idx != -1) { subcode = subcode.Substring(idx + 1); } switch (subcode) { case "ArgumentException": type = WsFaultType.ArgumentException; break; case "ArgumentNullException": type = WsFaultType.ArgumentNullException; break; case "Exception": type = WsFaultType.Exception; break; case "InvalidOperationException": type = WsFaultType.InvalidOperationException; break; case "XmlException": type = WsFaultType.XmlException; break; case "InvalidMessageInformationHeader": type = WsFaultType.WsaInvalidMessageInformationHeader; break; case "MessageInformationHeaderRequired": type = WsFaultType.WsaMessageInformationHeaderRequired; break; case "DestinationUnreachable": type = WsFaultType.WsaDestinationUnreachable; break; case "ActionNotSupported": type = WsFaultType.WsaActionNotSupported; break; case "EndpointUnavailable": type = WsFaultType.WsaEndpointUnavailable; break; case "DeliverModeRequestedUnavailable": type = WsFaultType.WseDeliverModeRequestedUnavailable; break; case "InvalidExpirationTime": type = WsFaultType.WseInvalidExpirationTime; break; case "UnsupportedExpirationType": type = WsFaultType.WseUnsupportedExpirationType; break; case "FilteringNotSupported": type = WsFaultType.WseFilteringNotSupported; break; case "FilteringRequestedUnavailable": type = WsFaultType.WseFilteringRequestedUnavailable; break; case "EventSourceUnableToProcess": type = WsFaultType.WseEventSourceUnableToProcess; break; case "UnableToRenew": type = WsFaultType.WseUnableToRenew; break; case "InvalidMessage": type = WsFaultType.WseInvalidMessage; break; } reader.ReadEndElement(); } reader.ReadEndElement(); // </Code> } if (reader.IsStartElement("Reason", WsWellKnownUri.SoapNamespaceUri)) { reader.ReadStartElement(); message = reader.ReadElementString("Text", WsWellKnownUri.SoapNamespaceUri); reader.ReadEndElement(); } if (reader.IsStartElement("Detail", WsWellKnownUri.SoapNamespaceUri)) { detail = reader.ReadElementString("Detail", WsWellKnownUri.SoapNamespaceUri); } if (!reader.IsStartElement()) { break; } } reader.ReadEndElement(); // </Fault> reader.ReadEndElement(); // </Body> throw new WsFaultException(header, type, message, detail); }
public override bool CanDeserialize(XmlReader xmlReader) { return(xmlReader.IsStartElement("ClassMetadata", "")); }
public static string[,] XmlToArray(string XML) { List <string> ParameterNames = new List <string>(); List <string> ParameterValues = new List <string>(); StringBuilder OutXml = new StringBuilder(); List <string> Paths = new List <string>(); StringReader XMLStringReader = new StringReader(XML.Trim()); XmlReader Reader = XmlReader.Create(XMLStringReader); int ParameterCount = 0; bool Read = true; bool NextRead = false; while (Read) { if (!NextRead) { Read = Reader.Read(); } NextRead = false; if (!Read) { continue; } if (Reader.IsStartElement()) { Paths.Add(Reader.Name); Read = Reader.Read(); if (Reader.NodeType == XmlNodeType.EndElement) { ParameterCount++; string Value = ""; ParameterNames.Add(JoinPaths(Paths)); ParameterValues.Add(Value); int C = Paths.Count; if (C > 0) { Paths.RemoveAt(C - 1); } } else { NextRead = true; } } else { if (Reader.NodeType == XmlNodeType.EndElement) { int C = Paths.Count; if (C > 0) { Paths.RemoveAt(C - 1); } } else { ParameterCount++; string Value = Reader.Value.Trim(); ParameterNames.Add(JoinPaths(Paths)); ParameterValues.Add(Value); } } } Reader.Close(); string[,] InjectionPoints = new string[ParameterNames.Count, 2]; for (int i = 0; i < ParameterNames.Count; i++) { InjectionPoints[i, 0] = ParameterNames[i]; InjectionPoints[i, 1] = ParameterValues[i]; } return(InjectionPoints); }
/// <summary> /// Loads the trained Eigen Recogniser from specified location /// </summary> /// <param name="filename"></param> public void Load_Eigen_Recogniser(string filename) { //Lets get the recogniser type from the file extension string ext = Path.GetExtension(filename); switch (ext) { case (".LBPH"): Recognizer_Type = "EMGU.CV.LBPHFaceRecognizer"; recognizer = new LBPHFaceRecognizer(1, 14, 10, 10, 3000);//50 break; case (".FFR"): Recognizer_Type = "EMGU.CV.FisherFaceRecognizer"; recognizer = new FisherFaceRecognizer(0, 3500);//4000 break; case (".EFR"): Recognizer_Type = "EMGU.CV.EigenFaceRecognizer"; recognizer = new EigenFaceRecognizer(80, double.PositiveInfinity); break; } //introduce error checking recognizer.Load(filename); //Now load the labels string direct = Path.GetDirectoryName(filename); Names_List.Clear(); if (File.Exists(direct + "/Labels.xml")) { FileStream filestream = File.OpenRead(direct + "/Labels.xml"); long filelength = filestream.Length; byte[] xmlBytes = new byte[filelength]; filestream.Read(xmlBytes, 0, (int)filelength); filestream.Close(); MemoryStream xmlStream = new MemoryStream(xmlBytes); using (XmlReader xmlreader = XmlTextReader.Create(xmlStream)) { while (xmlreader.Read()) { if (xmlreader.IsStartElement()) { switch (xmlreader.Name) { case "NAME": if (xmlreader.Read()) { Names_List.Add(xmlreader.Value.Trim()); } break; } } } } ContTrain = NumLabels; } _IsTrained = true; }
private void ReadDocument(XmlReader reader) { ServiceDocument result = CreateDocumentInstance(); try { SyndicationFeedFormatter.MoveToStartElement(reader); bool elementIsEmpty = reader.IsEmptyElement; if (reader.HasAttributes) { while (reader.MoveToNextAttribute()) { if (reader.LocalName == "lang" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs) { result.Language = reader.Value; } else if (reader.LocalName == "base" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs) { result.BaseUri = new Uri(reader.Value, UriKind.RelativeOrAbsolute); } else { string ns = reader.NamespaceURI; string name = reader.LocalName; if (FeedUtils.IsXmlns(name, ns) || FeedUtils.IsXmlSchemaType(name, ns)) { continue; } string val = reader.Value; if (!TryParseAttribute(name, ns, val, result, Version)) { result.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), reader.Value); } } } } XmlBuffer buffer = null; XmlDictionaryWriter extWriter = null; reader.ReadStartElement(); if (!elementIsEmpty) { try { while (reader.IsStartElement()) { if (reader.IsStartElement(App10Constants.Workspace, App10Constants.Namespace)) { result.Workspaces.Add(ReadWorkspace(reader, result)); } else if (!TryParseElement(reader, result, Version)) { SyndicationFeedFormatter.CreateBufferIfRequiredAndWriteNode(ref buffer, ref extWriter, reader, _maxExtensionSize); } } LoadElementExtensions(buffer, extWriter, result); } finally { extWriter?.Close(); } } reader.ReadEndElement(); } catch (FormatException e) { throw new XmlException(FeedUtils.AddLineInfo(reader, SR.ErrorParsingDocument), e); } catch (ArgumentException e) { throw new XmlException(FeedUtils.AddLineInfo(reader, SR.ErrorParsingDocument), e); } SetDocument(result); }
private static void ReadReferencedCategories(XmlReader reader, ReferencedCategoriesDocument referencedCategories, Uri baseUri, Uri link, string version, int maxExtensionSize) { referencedCategories.BaseUri = baseUri; referencedCategories.Link = link; if (reader.HasAttributes) { while (reader.MoveToNextAttribute()) { if (reader.LocalName == "base" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs) { referencedCategories.BaseUri = FeedUtils.CombineXmlBase(referencedCategories.BaseUri, reader.Value); } else if (reader.LocalName == "lang" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs) { referencedCategories.Language = reader.Value; } else if (reader.LocalName == App10Constants.Href && reader.NamespaceURI == string.Empty) { continue; } else { string ns = reader.NamespaceURI; string name = reader.LocalName; if (FeedUtils.IsXmlns(name, ns) || FeedUtils.IsXmlSchemaType(name, ns)) { continue; } string val = reader.Value; if (!TryParseAttribute(name, ns, val, referencedCategories, version)) { referencedCategories.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), reader.Value); } } } } reader.MoveToElement(); bool isEmptyElement = reader.IsEmptyElement; reader.ReadStartElement(); if (!isEmptyElement) { XmlBuffer buffer = null; XmlDictionaryWriter extWriter = null; try { while (reader.IsStartElement()) { if (!TryParseElement(reader, referencedCategories, version)) { SyndicationFeedFormatter.CreateBufferIfRequiredAndWriteNode(ref buffer, ref extWriter, reader, maxExtensionSize); } } LoadElementExtensions(buffer, extWriter, referencedCategories); } finally { extWriter?.Close(); } reader.ReadEndElement(); } }
public void filterRegionsSeriallyXML(string input) { string regionsFileName = resultsDirectory + OSseparator + outfileName + "_filtered_regions." + fileType; StreamWriter outputRegion = new StreamWriter(@"" + regionsFileName); string peaksInRegionsFileName = resultsDirectory + OSseparator + outfileName + "_filtered_regions_peaks." + fileType; StreamWriter outputPeak = new StreamWriter(@"" + peaksInRegionsFileName); string xmlFileName = resultsDirectory + OSseparator + outfileName + "_filtered_regions.xml"; XmlWriterSettings settings = new XmlWriterSettings(); settings.Indent = true; settings.IndentChars = "\t"; XmlWriter writer = XmlWriter.Create(@"" + xmlFileName, settings); writer.WriteStartDocument(); writer.WriteStartElement("regs"); XmlReader reader = XmlReader.Create(@"" + inputFile); XmlReader sTree; XElement regionElement; region newRegion, previousRegion = null; int elementCounter = 1, attributeCounter = 1, lineCounter = 2; while (reader.ReadToFollowing("reg")) { if (reader.IsStartElement()) { sTree = reader.ReadSubtree(); regionElement = XElement.Load(sTree); lineCounter++; newRegion = regionFromXML(regionElement, inputFile, elementCounter, lineCounter); newRegion.peakList = new List <peak>(); attributeCounter = 1; foreach (XElement peakElement in regionElement.Descendants("pk")) { lineCounter++; newRegion.peakList.Add(peakFromXML(peakElement, inputFile, elementCounter, attributeCounter, lineCounter)); attributeCounter++; } elementCounter++; lineCounter++; if (filterRegion(newRegion)) { previousRegion = calculateStatisticData(newRegion, previousRegion); printRegion(newRegion, outputRegion, outputPeak); writeRegionInXML(writer, newRegion); } } else { break; } } outputRegion.Close(); outputPeak.Close(); writer.WriteEndElement(); writer.WriteEndDocument(); writer.Close(); if (!peakFile) { File.Delete(@"" + peaksInRegionsFileName); } if (!xmlFile) { File.Delete(@"" + xmlFileName); } Console.WriteLine("done!"); }
public override bool CanReadToken(XmlReader reader) => reader?.IsStartElement("BinarySecurityToken", WsSecurityConstants.WsSecurity10.Namespace) == true && reader.GetAttribute("ValueType") == "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-x509-token-profile-1.0#X509v3" && reader.GetAttribute("EncodingType") == "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-soap-message-security-1.0#Base64Binary" ;
private bool LoadTrainingData(string Folder_location) { if (File.Exists(Folder_location + "\\" + XmlVeriDosyasi)) { try { Names_List.Clear(); trainingImages.Clear(); FileStream filestream = File.OpenRead(Folder_location + "\\" + XmlVeriDosyasi); long filelength = filestream.Length; byte[] xmlBytes = new byte[filelength]; filestream.Read(xmlBytes, 0, (int)filelength); filestream.Close(); MemoryStream xmlStream = new MemoryStream(xmlBytes); using (XmlReader xmlreader = XmlTextReader.Create(xmlStream)) { while (xmlreader.Read()) { if (xmlreader.IsStartElement()) { switch (xmlreader.Name) { case "NAME": if (xmlreader.Read()) { Names_List.Add(xmlreader.Value.Trim()); NumLabels += 1; } break; case "FILE": if (xmlreader.Read()) { trainingImages.Add(new Image <Gray, byte>(Dizin + "\\" + xmlreader.Value.Trim())); } break; } } } } ContTrain = NumLabels; if (trainingImages.ToArray().Length != 0) { recognizer = new EigenObjectRecognizer(trainingImages.ToArray(), Names_List.ToArray(), 5000, ref termCrit); return(true); } else { return(false); } } catch (Exception ex) { Error = ex.ToString(); return(false); } } else { return(false); } }
/// <summary> /// Generates a serializable continuation token from its XML representation. /// </summary> /// <param name="reader">The <see cref="T:System.Xml.XmlReader"/> stream from which the continuation token is deserialized.</param> public void ReadXml(XmlReader reader) { if (reader == null) { throw new ArgumentNullException("reader"); } reader.MoveToContent(); if (reader.IsEmptyElement) { reader.Skip(); } else { reader.ReadStartElement(); while (reader.IsStartElement()) { if (reader.IsEmptyElement) { reader.Skip(); } else { switch (reader.Name) { case Constants.ContinuationConstants.VersionElement: string version = reader.ReadElementContentAsString(); if (version != Constants.ContinuationConstants.CurrentVersion) { throw new XmlException(string.Format(CultureInfo.InvariantCulture, SR.UnexpectedElement, version)); } break; case Constants.ContinuationConstants.NextPartitionKeyElement: this.NextPartitionKey = reader.ReadElementContentAsString(); break; case Constants.ContinuationConstants.NextRowKeyElement: this.NextRowKey = reader.ReadElementContentAsString(); break; case Constants.ContinuationConstants.NextTableNameElement: this.NextTableName = reader.ReadElementContentAsString(); break; case Constants.ContinuationConstants.TypeElement: string continuationType = reader.ReadElementContentAsString(); if (Constants.ContinuationConstants.TableType != continuationType) { throw new XmlException(SR.UnexpectedContinuationType); } break; default: throw new XmlException(string.Format(CultureInfo.InvariantCulture, SR.UnexpectedElement, reader.Name)); } } } reader.ReadEndElement(); } }
public static void AddEOSComp(XmlReader rdr, Computer compAttatchedTo, object osObj) { var os = (OS)osObj; var compName = "Unregistered eOS Device"; var str1 = compAttatchedTo.idName + "_eos"; if (rdr.MoveToAttribute("name")) { compName = rdr.ReadContentAsString(); } if (rdr.MoveToAttribute("id")) { str1 = rdr.ReadContentAsString(); } var device = new Computer(compName, NetworkMap.generateRandomIP(), os.netMap.getRandomPosition(), 0, 5, os); device.idName = str1; var str2 = "ePhone"; if (rdr.MoveToAttribute("icon")) { str2 = rdr.ReadContentAsString(); } device.icon = str2; device.location = compAttatchedTo.location + Corporation.getNearbyNodeOffset(compAttatchedTo.location, Utils.random.Next(12), 12, os.netMap); device.setAdminPassword("alpine"); ComputerLoader.loadPortsIntoComputer("22,3659", device); device.portsNeededForCrack = 2; GenerateEOSFilesystem(device); rdr.Read(); var folder1 = device.files.root.searchForFolder("eos"); var folder2 = folder1.searchForFolder("notes"); var folder3 = folder1.searchForFolder("mail"); while (!(rdr.Name == "eosDevice") || rdr.IsStartElement()) { if (rdr.Name.ToLower() == "note" && rdr.IsStartElement()) { string nameEntry = null; if (rdr.MoveToAttribute("filename")) { nameEntry = rdr.ReadContentAsString(); } var num = (int)rdr.MoveToContent(); var dataEntry = rdr.ReadElementContentAsString().TrimStart(); if (nameEntry == null) { var length = dataEntry.IndexOf("\n"); if (length == -1) { length = dataEntry.IndexOf("\n"); } if (length == -1) { length = dataEntry.Length; } nameEntry = dataEntry.Substring(0, length).Replace(" ", "_").ToLower().Trim() + ".txt"; } var fileEntry = new FileEntry(dataEntry, nameEntry); folder2.files.Add(fileEntry); } if (rdr.Name.ToLower() == "mail" && rdr.IsStartElement()) { string str3 = null; string str4 = null; if (rdr.MoveToAttribute("username")) { str3 = rdr.ReadContentAsString(); } if (rdr.MoveToAttribute("pass")) { str4 = rdr.ReadContentAsString(); } var dataEntry = "MAIL ACCOUNT : " + str3 + "\nAccount :" + str3 + "\nPassword :"******"\nLast Sync :" + DateTime.Now + "\n\n" + Computer.generateBinaryString(512); var nameEntry = str3 + ".act"; folder3.files.Add(new FileEntry(dataEntry, nameEntry)); } rdr.Read(); if (rdr.EOF) { break; } } os.netMap.nodes.Add(device); ComputerLoader.postAllLoadedActions += () => device.links.Add(os.netMap.nodes.IndexOf(compAttatchedTo)); if (compAttatchedTo.attatchedDeviceIDs != null) { compAttatchedTo.attatchedDeviceIDs += ","; } compAttatchedTo.attatchedDeviceIDs += device.idName; }
internal bool IsStartElement() #endif { return(!isEndOfEmptyElement && reader.IsStartElement()); }
public override bool IsStartElement() { return(innerReader.IsStartElement()); }
/// <summary> /// private helper file that will read the xml file and convert it into a saved spreadsheet /// the readFile method will also /// /// </summary> private string readFile(string filename, bool getVersioninfo) { if (ReferenceEquals(filename, null)) { throw new SpreadsheetReadWriteException("filename is null"); } if (filename.Equals("")) { throw new SpreadsheetReadWriteException("filename is empty"); } try { using (XmlReader reader = XmlReader.Create(filename)) { string name = ""; string content = ""; while (reader.Read()) { if (reader.IsStartElement()) { switch (reader.Name) { case "spreadsheet": if (getVersioninfo) { return(reader["version"]); } Version = reader["version"]; break; case "name": if (getVersioninfo) { throw new SpreadsheetReadWriteException("file read error"); } else { reader.Read(); name = reader.Value; } break; case "cell": if (getVersioninfo) { throw new SpreadsheetReadWriteException("file read error"); } break; case "contents": if (getVersioninfo) { throw new SpreadsheetReadWriteException("file read error"); } reader.Read(); content = reader.Value; SetContentsOfCell(name, content); break; } } } } } catch (XmlException e) { throw new SpreadsheetReadWriteException(e.ToString()); } catch (IOException e) { throw new SpreadsheetReadWriteException(e.ToString()); } return(Version); }
public Spreadsheet(string path, Func <string, bool> isValid, Func <string, string> normalize, string FileVersion) : base(isValid, normalize, FileVersion) { bool openfile = true; XmlReaderSettings settings = new XmlReaderSettings(); settings.IgnoreWhitespace = true; try { using (XmlReader reader = XmlReader.Create(path, settings)) { while (openfile) { //read the next element if (reader.Read()) { if (reader.IsStartElement()) { //if spreadsheet get version if (reader.Name == "spreadsheet") { Version = reader.GetAttribute("version"); } //if cell get name and contents else if (reader.Name == "cell") { string name = ""; string contents = ""; reader.Read(); if (reader.IsStartElement()) { if (reader.Name == "name") { reader.Read(); name = reader.Value; reader.Read(); reader.ReadEndElement(); } //if element isn't name, throw exception else { throw new SpreadsheetReadWriteException("Cell not written correctly"); } } //if element doesn't exist, throw exception if (reader.IsStartElement()) { if (reader.Name == "contents") { reader.Read(); contents = reader.Value; reader.Read(); reader.ReadEndElement(); } //if element isn't contents, throw exception else { throw new SpreadsheetReadWriteException("Cell not written in correct order"); } } //once we have the name and contents, set the contents of the cell SetContentsOfCell(name, contents); } else { throw new SpreadsheetReadWriteException("Invalid element property"); } } } else { openfile = false; } } //if it's not a valid version number, throw exception if (Version != FileVersion) { throw new SpreadsheetReadWriteException("Invalid Version Number"); } } Changed = false; } //catching the different SS exceptions and throwing them. otherwise, if it is a read write exception, throw that. catch (CircularException E) { throw E; } catch (InvalidNameException E) { throw E; } catch (SpreadsheetReadWriteException E) { throw E; } catch (Exception) { throw new SpreadsheetReadWriteException("Error reading or writing spreadsheet"); } }
private object ReadObject(string classname, List<object> list, XmlReader reader) { object res = null; int count = 0; string attribute = null; int fieldcount; if (classname == null) { reader.Read(); if (reader.IsStartElement()) classname = XmlConvert.DecodeName(reader.Name); count = Convert.ToInt32(reader["count"]); } if (classname == null) return null; fieldcount = Convert.ToInt32(reader["fieldcount"]); attribute = reader["reference"]; reader.Read(); if (reader.IsStartElement() || reader.Value != null) { Type objtype = Type.GetType(classname); if (attribute != null) { // string attribute = reader["reference"]; if (attribute != null) { res = list[Convert.ToInt32(attribute)]; } } else if (objtype.IsPrimitive) { res = (object)objtype.InvokeMember("Parse", BindingFlags.InvokeMethod | BindingFlags.Static | BindingFlags.Public, null, null, new object[] { XmlConvert.DecodeName(reader.Value.Trim()) }); list.Add(res); } else if (objtype.Equals(typeof(string))) { res = XmlConvert.DecodeName(reader.Value.Trim()); } else { if (objtype.IsArray) { //count = Convert.ToInt32(reader["count"]); int index = 0; res = Activator.CreateInstance(objtype, count); list.Add(res); while (index < count) { //reader.Read(); while(!reader.IsStartElement()) reader.Read(); string s = reader.Name; ((System.Array)res).SetValue(ReadObject(s, list, reader), index++); } } else { res = Activator.CreateInstance(objtype); list.Add(res); int index = 0; //count = Convert.ToInt32(reader["count"]); while (index < fieldcount) { while (!reader.IsStartElement()) reader.Read(); index++; string fieldname = reader.Name; object fieldobject = ReadObject(null, list, reader); FieldInfo fiendinf = objtype.GetField(fieldname, BindingFlags.GetField | BindingFlags.SetField | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance); if (fiendinf != null) fiendinf.SetValue(res, fieldobject); } } } } return res; }
private static bool LoadTrainingData(String folder) { if (File.Exists(folder + "\\TrainedLabels.xml")) { countTrain = 0; labels.Clear(); labelsID.Clear(); trainingImages.Clear(); FileStream filestream = File.OpenRead(folder + "\\TrainedLabels.xml"); long fileLength = filestream.Length; byte[] xmlBytes = new byte[fileLength]; filestream.Read(xmlBytes, 0, (int)fileLength); filestream.Dispose(); MemoryStream xmlStream = new MemoryStream(xmlBytes); using (XmlReader xmlReader = XmlTextReader.Create(xmlStream)) { while (xmlReader.Read()) { if (xmlReader.IsStartElement()) { switch (xmlReader.Name) { case "NAME": if (xmlReader.Read()) { labelsID.Add(labels.Count); labels.Add(xmlReader.Value.Trim()); countTrain += 1; } break; case "FILE": if (xmlReader.Read()) { trainingImages.Add(new Image <Gray, byte>(folder + "\\" + xmlReader.Value.Trim())); } break; } } } } xmlStream.Dispose(); filestream.Dispose(); if (countTrain != 0) { try { faceRecognizer.Train(trainingImages.ToArray(), labelsID.ToArray()); } catch (Exception e) { MessageBox.Show(e.Message); } } return(true); } else { return(false); } }
private static void ReadInlineCategories(XmlReader reader, InlineCategoriesDocument inlineCategories, Uri baseUri, string version, int maxExtensionSize) { inlineCategories.BaseUri = baseUri; if (reader.HasAttributes) { while (reader.MoveToNextAttribute()) { if (reader.LocalName == "base" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs) { inlineCategories.BaseUri = FeedUtils.CombineXmlBase(inlineCategories.BaseUri, reader.Value); } else if (reader.LocalName == "lang" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs) { inlineCategories.Language = reader.Value; } else if (reader.LocalName == App10Constants.Fixed && reader.NamespaceURI == string.Empty) { inlineCategories.IsFixed = (reader.Value == "yes"); } else if (reader.LocalName == Atom10Constants.SchemeTag && reader.NamespaceURI == string.Empty) { inlineCategories.Scheme = reader.Value; } else { string ns = reader.NamespaceURI; string name = reader.LocalName; if (FeedUtils.IsXmlns(name, ns) || FeedUtils.IsXmlSchemaType(name, ns)) { continue; } string val = reader.Value; if (!TryParseAttribute(name, ns, val, inlineCategories, version)) { inlineCategories.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), reader.Value); } } } } SyndicationFeedFormatter.MoveToStartElement(reader); bool isEmptyElement = reader.IsEmptyElement; reader.ReadStartElement(); if (!isEmptyElement) { XmlBuffer buffer = null; XmlDictionaryWriter extWriter = null; try { while (reader.IsStartElement()) { if (reader.IsStartElement(Atom10Constants.CategoryTag, Atom10Constants.Atom10Namespace)) { SyndicationCategory category = CreateCategory(inlineCategories); Atom10FeedFormatter.ReadCategory(reader, category, version, preserveAttributeExtensions: true, preserveElementExtensions: true, maxExtensionSize); category.Scheme ??= inlineCategories.Scheme; inlineCategories.Categories.Add(category); } else if (!TryParseElement(reader, inlineCategories, version)) { SyndicationFeedFormatter.CreateBufferIfRequiredAndWriteNode(ref buffer, ref extWriter, reader, maxExtensionSize); } } LoadElementExtensions(buffer, extWriter, inlineCategories); } finally { extWriter?.Close(); } reader.ReadEndElement(); } }
public override bool CanDeserialize(XmlReader xmlReader) { return(xmlReader.IsStartElement("AutoAttendantSettings", string.Empty)); }
private ResourceCollectionInfo ReadCollection(XmlReader reader, Workspace workspace) { ResourceCollectionInfo result = CreateCollection(workspace); result.BaseUri = workspace.BaseUri; if (reader.HasAttributes) { while (reader.MoveToNextAttribute()) { if (reader.LocalName == "base" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs) { result.BaseUri = FeedUtils.CombineXmlBase(result.BaseUri, reader.Value); } else if (reader.LocalName == App10Constants.Href && reader.NamespaceURI == string.Empty) { result.Link = new Uri(reader.Value, UriKind.RelativeOrAbsolute); } else { string ns = reader.NamespaceURI; string name = reader.LocalName; if (FeedUtils.IsXmlns(name, ns) || FeedUtils.IsXmlSchemaType(name, ns)) { continue; } string val = reader.Value; if (!TryParseAttribute(name, ns, val, result, Version)) { result.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), reader.Value); } } } } XmlBuffer buffer = null; XmlDictionaryWriter extWriter = null; reader.ReadStartElement(); try { while (reader.IsStartElement()) { if (reader.IsStartElement(Atom10Constants.TitleTag, Atom10Constants.Atom10Namespace)) { result.Title = Atom10FeedFormatter.ReadTextContentFrom(reader, "//app:service/app:workspace/app:collection/atom:title[@type]", preserveAttributeExtensions: true); } else if (reader.IsStartElement(App10Constants.Categories, App10Constants.Namespace)) { result.Categories.Add(ReadCategories(reader, result.BaseUri, () => CreateInlineCategories(result), () => CreateReferencedCategories(result), Version, _maxExtensionSize)); } else if (reader.IsStartElement(App10Constants.Accept, App10Constants.Namespace)) { result.Accepts.Add(reader.ReadElementString()); } else if (!TryParseElement(reader, result, Version)) { SyndicationFeedFormatter.CreateBufferIfRequiredAndWriteNode(ref buffer, ref extWriter, reader, _maxExtensionSize); } } LoadElementExtensions(buffer, extWriter, result); } finally { extWriter?.Close(); } reader.ReadEndElement(); return(result); }
/// <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 byte[] Subscribe(WsWsaHeader header, XmlReader reader, WsServiceEndpoints serviceEndpoints) { // Parse Subscribe Request ///////////////////////////// DpwsWseEventSink eventSink = new DpwsWseEventSink(); try { reader.ReadStartElement("Subscribe", WsWellKnownUri.WseNamespaceUri); if (reader.IsStartElement("EndTo", WsWellKnownUri.WseNamespaceUri)) { eventSink.EndTo = new WsWsaEndpointRef(reader); } reader.ReadStartElement("Delivery", WsWellKnownUri.WseNamespaceUri); if (reader.IsStartElement("NotifyTo", WsWellKnownUri.WseNamespaceUri)) { eventSink.NotifyTo = new WsWsaEndpointRef(reader); } 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 != "http://schemas.xmlsoap.org/ws/2006/02/devprof/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 ////////////////////////// MemoryStream soapStream = new MemoryStream(); XmlWriter xmlWriter = XmlWriter.Create(soapStream); WsWsaHeader responseHeader = new WsWsaHeader( WsWellKnownUri.WseNamespaceUri + "/SubscribeResponse", // Action header.MessageID, // RelatesTo header.ReplyTo.Address.AbsoluteUri, // To null, null, null); // ReplyTo, From, Any WsSoapMessageWriter.WriteSoapMessageStart(xmlWriter, WsSoapMessageWriter.Prefixes.Wse, // Prefix null, // Additional Prefix responseHeader, // Header new WsSoapMessageWriter.AppSequence(Device.AppSequence, Device.SequenceID, Device.MessageID)); // AppSequence // write body xmlWriter.WriteStartElement("wse", "SubscribeResponse", null); xmlWriter.WriteStartElement("wse", "SubscriptionManager", null); xmlWriter.WriteStartElement("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("wsa", "ReferenceParameters", null); xmlWriter.WriteStartElement("wse", "Identifier", null); xmlWriter.WriteString(eventSink.ID); xmlWriter.WriteEndElement(); // End Identifier xmlWriter.WriteEndElement(); // End ReferenceParameters xmlWriter.WriteEndElement(); // End SubscriptionManager xmlWriter.WriteStartElement("wse", "Expires", null); xmlWriter.WriteString(new WsDuration(eventSink.Expires).DurationString); xmlWriter.WriteEndElement(); // End Expires xmlWriter.WriteEndElement(); // End SubscribeResponse WsSoapMessageWriter.WriteSoapMessageEnd(xmlWriter); // Flush and close writer. Return stream buffer xmlWriter.Flush(); xmlWriter.Close(); return(soapStream.ToArray()); }
private Workspace ReadWorkspace(XmlReader reader, ServiceDocument document) { Workspace result = CreateWorkspace(document); result.BaseUri = document.BaseUri; if (reader.HasAttributes) { while (reader.MoveToNextAttribute()) { if (reader.LocalName == "base" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs) { result.BaseUri = FeedUtils.CombineXmlBase(result.BaseUri, reader.Value); } else { string ns = reader.NamespaceURI; string name = reader.LocalName; if (FeedUtils.IsXmlns(name, ns) || FeedUtils.IsXmlSchemaType(name, ns)) { continue; } string val = reader.Value; if (!TryParseAttribute(name, ns, val, result, Version)) { result.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), reader.Value); } } } } XmlBuffer buffer = null; XmlDictionaryWriter extWriter = null; reader.ReadStartElement(); try { while (reader.IsStartElement()) { if (reader.IsStartElement(Atom10Constants.TitleTag, Atom10Constants.Atom10Namespace)) { result.Title = Atom10FeedFormatter.ReadTextContentFrom(reader, "//app:service/app:workspace/atom:title[@type]", preserveAttributeExtensions: true); } else if (reader.IsStartElement(App10Constants.Collection, App10Constants.Namespace)) { result.Collections.Add(ReadCollection(reader, result)); } else if (!TryParseElement(reader, result, Version)) { SyndicationFeedFormatter.CreateBufferIfRequiredAndWriteNode(ref buffer, ref extWriter, reader, _maxExtensionSize); } } LoadElementExtensions(buffer, extWriter, result); } finally { extWriter?.Close(); } reader.ReadEndElement(); return(result); }
/// <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 byte[] 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; for (int i = 0; i < serviceEndpoints.Count; ++i) { if (serviceEndpoints[i].EndpointAddress == endpointAddress) { if ((eventSink = GetEventSink(((DpwsHostedService)serviceEndpoints[i]).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); }
/// <summary> /// Loads the traing data given a (string) folder location /// </summary> /// <param name="Folder_location"></param> /// <returns></returns> private bool LoadTrainingData(string Folder_location) { if (File.Exists(Folder_location + "\\TrainedLabels.xml")) { try { //message_bar.Text = ""; Names_List.Clear(); Names_List_ID.Clear(); trainingImages.Clear(); FileStream filestream = File.OpenRead(Folder_location + "\\TrainedLabels.xml"); long filelength = filestream.Length; byte[] xmlBytes = new byte[filelength]; filestream.Read(xmlBytes, 0, (int)filelength); filestream.Close(); MemoryStream xmlStream = new MemoryStream(xmlBytes); using (XmlReader xmlreader = XmlTextReader.Create(xmlStream)) { while (xmlreader.Read()) { if (xmlreader.IsStartElement()) { switch (xmlreader.Name) { case "NAME": if (xmlreader.Read()) { Names_List_ID.Add(Names_List.Count); //0, 1, 2, 3.... Names_List.Add(xmlreader.Value.Trim()); NumLabels += 1; } break; case "FILE": if (xmlreader.Read()) { //PROBLEM HERE IF TRAININGG MOVED trainingImages.Add(new Image <Gray, byte>(Application.StartupPath + "\\TrainedFaces\\" + xmlreader.Value.Trim())); } break; } } } } ContTrain = NumLabels; if (trainingImages.ToArray().Length != 0) { //Eigen face recognizer //Parameters: // num_components – The number of components (read: Eigenfaces) kept for this Prinicpal // Component Analysis. As a hint: There’s no rule how many components (read: Eigenfaces) // should be kept for good reconstruction capabilities. It is based on your input data, // so experiment with the number. Keeping 80 components should almost always be sufficient. // // threshold – The threshold applied in the prediciton. This still has issues as it work inversly to LBH and Fisher Methods. // if you use 0.0 recognizer.Predict will always return -1 or unknown if you use 5000 for example unknow won't be reconised. // As in previous versions I ignore the built in threhold methods and allow a match to be found i.e. double.PositiveInfinity // and then use the eigen distance threshold that is return to elliminate unknowns. // //NOTE: The following causes the confusion, sinc two rules are used. //-------------------------------------------------------------------------------------------------------------------------------------- //Eigen Uses // 0 - X = unknown // > X = Recognised // //Fisher and LBPH Use // 0 - X = Recognised // > X = Unknown // // Where X = Threshold value switch (Recognizer_Type) { case ("EMGU.CV.LBPHFaceRecognizer"): recognizer = new LBPHFaceRecognizer(1, 8, 8, 8, 100); //50 break; case ("EMGU.CV.FisherFaceRecognizer"): recognizer = new FisherFaceRecognizer(0, 4000); //4000 break; case ("EMGU.CV.EigenFaceRecognizer"): default: recognizer = new EigenFaceRecognizer(80, double.PositiveInfinity); break; } recognizer.Train(trainingImages.ToArray(), Names_List_ID.ToArray()); // Recognizer_Type = recognizer.GetType(); // string v = recognizer.ToString(); //EMGU.CV.FisherFaceRecognizer || EMGU.CV.EigenFaceRecognizer || EMGU.CV.LBPHFaceRecognizer return(true); } else { return(false); } } catch (Exception ex) { Error = ex.ToString(); return(false); } } else { return(false); } }
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; } } }
public static string InjectInXml(string XML, int InjectionPosition, string Payload) { //StringBuilder OutXml = new StringBuilder(); StringReader XMLStringReader = new StringReader(XML.Trim()); XmlReader Reader = XmlReader.Create(XMLStringReader); //XmlWriter Writer = XmlWriter.Create(OutXml); StringWriter OutXml = new StringWriter(); XmlTextWriter Writer = new XmlTextWriter(OutXml); int ParameterCount = 0; bool Read = true; bool NextRead = false; while (Read) { if (!NextRead) { Read = Reader.Read(); } NextRead = false; if (!Read) { continue; } if (Reader.IsStartElement()) { Writer.WriteStartElement(Reader.Name); if (Reader.HasAttributes) { Writer.WriteAttributes(Reader, false); } Read = Reader.Read(); if (Reader.NodeType == XmlNodeType.EndElement) { if (ParameterCount == InjectionPosition) { Writer.WriteString(Payload); } else { Writer.WriteString(""); } ParameterCount++; Writer.WriteEndElement(); } else { NextRead = true; } } else { if (Reader.NodeType == XmlNodeType.EndElement) { Writer.WriteEndElement(); } else { if (ParameterCount == InjectionPosition) { Writer.WriteString(Payload); } else { Writer.WriteString(Reader.Value); } ParameterCount++; } } } Reader.Close(); Writer.Close(); OutXml.Close(); //string OutXmlString = OutXml.ToString().Split(new string[] { "?>" }, 2, StringSplitOptions.None)[1]; return(OutXml.ToString()); }
public override bool CanDeserialize(XmlReader xmlReader) { return(xmlReader.IsStartElement("Root", "WorkingHours.xsd")); }
/// <summary> /// Loads a terrain into the scene from a file. /// <see cref="WorldManager.LoadAndGenerateMap"/> should be used unless additional custom modification will be used. /// This method only loads the data into memory and does not generate the world from the data. /// </summary> /// <param name="location">File to load</param> /// <remarks> /// <see cref="WorldManager.LoadAndGenerateMap"/> should be used instead of this method unless advanced custom work needs to be implimented. /// </remarks> public static void LoadTerrain(string location) { WorldManager worldManager = GameObject.FindObjectOfType <WorldManager>(); if (worldManager == null) { Debug.LogError("WorldManager not found while attempting to load the game. \n Game load failed. "); return; } bool startedGen = false; using (XmlReader reader = XmlReader.Create(location + ".xml")) { while (reader.Read()) { if (reader.IsStartElement()) { switch (reader.Name) { case "WorldManager": worldManager.useCivGridCamera = XmlConvert.ToBoolean(reader["useCivGridCamera"]); worldManager.useWorldTypeValues = XmlConvert.ToBoolean(reader["usePresetWorldValue"]); worldManager.worldType = (WorldType)XmlConvert.ToInt32(reader["worldType"]); worldManager.mapSize = new Vector2(XmlConvert.ToInt32(reader["mapSizeX"]), XmlConvert.ToInt32(reader["mapSizeY"])); worldManager.chunkSize = XmlConvert.ToInt32(reader["chunkSize"]); worldManager.hexRadiusSize = (float)XmlConvert.ToDouble(reader["hexRadiusSize"]); worldManager.mountainHeightMap = FileUtility.LoadTexture("Base_Mountain_Map"); break; case "CivGridCamera": worldManager.civGridCamera.enableWrapping = XmlConvert.ToBoolean(reader["enableWrapping"]); worldManager.civGridCamera.cameraHeight = (float)XmlConvert.ToDouble(reader["cameraHeight"]); worldManager.civGridCamera.cameraAngle = (float)XmlConvert.ToDouble(reader["cameraAngle"]); worldManager.civGridCamera.cameraSpeed = (float)XmlConvert.ToDouble(reader["cameraSpeed"]); break; case "Chunk": if (startedGen == false) { worldManager.GenerateNewMap(false); startedGen = true; } break; case "Hexagon": Hex hex = worldManager.hexChunks[XmlConvert.ToInt32(reader["xParentChunk"]), XmlConvert.ToInt32(reader["yParentChunk"])].hexArray[XmlConvert.ToInt32(reader["xHexLoc"]), XmlConvert.ToInt32(reader["yHexLoc"])]; hex.terrainType = worldManager.tileManager.TryGetTile(reader["type"]); hex.terrainFeature = (Feature)XmlConvert.ToInt32(reader["feature"]); hex.parentChunk = worldManager.hexChunks[XmlConvert.ToInt32(reader["xParentChunk"]), XmlConvert.ToInt32(reader["yParentChunk"])]; //rectLocation hex.currentRectLocation = new Rect((float)XmlConvert.ToDouble(reader["rLeft"]), (float)XmlConvert.ToDouble(reader["rTop"]), (float)XmlConvert.ToDouble(reader["rWidth"]), (float)XmlConvert.ToDouble(reader["rHeight"])); hex.currentResource = worldManager.resourceManager.TryGetResource(reader["resource"]); hex.currentImprovement = worldManager.improvementManager.TryGetImprovement(reader["improvement"]); break; #region VoidedManagers /* #region TileManager * case "TileManager": * Debug.Log("opening tile manager"); * break; * case "Tiles": * Debug.Log("finding tiles"); * break; * case "NewTile": * Debug.Log("adding Tile: " + reader["name"]); * tileManager.AddTile(new Tile(reader["name"], XmlConvert.ToBoolean(reader["isShore"]), XmlConvert.ToBoolean(reader["isOcean"]), XmlConvert.ToBoolean(reader["isMountain"]), (float)XmlConvert.ToDouble(reader["bottomLongitude"]), (float)XmlConvert.ToDouble(reader["topLongitude"]))); * break; #endregion #region ResourceManager * case "ResourceManager": * Debug.Log("opening resource manager"); * break; * case "Resources": * Debug.Log("opening resources"); * break; * case "NewResource": * string loc1 = reader["meshToSpawn"]; * string loc2 = reader["meshTexture"]; * * List<int> possibleTiles = new List<int>(); * List<Feature> possibleFeatures = new List<Feature>(); * * for(int i = 0; i < XmlConvert.ToInt32(reader["numOfPossibleTiles"]); i++) * { * possibleTiles.Add(XmlConvert.ToInt32(reader["possibleTile" + i])); * } * * for (int i = 0; i < XmlConvert.ToInt32(reader["numOfPossibleFeatures"]); i++) * { * possibleFeatures.Add((Feature)System.Enum.Parse(typeof(Feature), reader["possibleFeature" + i])); * } * * resourceManager.resources.Add(new Resource( * reader["name"], * ((float)XmlConvert.ToDouble(reader["rarity"])), * XmlConvert.ToInt32(reader["spawnAmount"]), * ((Mesh)AssetDatabase.LoadAssetAtPath(loc1, typeof(Mesh))), * ((Texture2D)AssetDatabase.LoadAssetAtPath(loc2, typeof(Texture2D))), * XmlConvert.ToBoolean(reader["replaceGroundTexture"]), new ResourceRule(possibleTiles.ToArray(), possibleFeatures.ToArray()))); * break; #endregion */ #endregion default: //Debug.Log("unhandled exception: " + reader.Name); break; } } } } foreach (Chunk chunk in worldManager.hexChunks) { chunk.StartHexGeneration(); foreach (Hex hex in chunk.hexArray) { if (hex.currentResource.name != "None") { worldManager.resourceManager.SpawnResource(hex, hex.currentResource, true); } if (hex.currentImprovement.name != "None") { worldManager.improvementManager.AddImprovement(hex.currentImprovement); } } } }
/// <summary> /// Creates an instance of a DpwsMetadata class. /// </summary> public DpwsMetadata(XmlReader reader) { reader.ReadStartElement("Metadata", WsWellKnownUri.WsxNamespaceUri); while (reader.IsStartElement("MetadataSection", WsWellKnownUri.WsxNamespaceUri)) { reader.MoveToAttribute("Dialect"); String dialect = reader.Value; reader.MoveToElement(); reader.Read(); // MetadataSection if (dialect == WsWellKnownUri.WsdpNamespaceUri + "/ThisModel") { #if DEBUG int depth = reader.Depth; #endif this.ThisModel = new DpwsThisModel(reader); #if DEBUG Microsoft.SPOT.Debug.Assert(XmlReaderHelper.HasReadCompleteNode(depth, reader)); #endif } else if (dialect == WsWellKnownUri.WsdpNamespaceUri + "/ThisDevice") { #if DEBUG int depth = reader.Depth; #endif this.ThisDevice = new DpwsThisDevice(reader); #if DEBUG Microsoft.SPOT.Debug.Assert(XmlReaderHelper.HasReadCompleteNode(depth, reader)); #endif } else if (dialect == WsWellKnownUri.WsdpNamespaceUri + "/Relationship") { #if DEBUG int depth = reader.Depth; #endif if (this.Relationship == null) { this.Relationship = new DpwsRelationship(reader); } else { this.Relationship.Append(reader); } #if DEBUG Microsoft.SPOT.Debug.Assert(XmlReaderHelper.HasReadCompleteNode(depth, reader)); #endif } else // known dialect { reader.Skip(); } reader.ReadEndElement(); // MetadataSection } if (this.ThisModel == null || this.ThisDevice == null || this.Relationship == null) { // Metadata must include ThisModel (R2038, R2012), ThisDevice(R2039, R2014), // at least one Relationship(R2040, R2029) throw new XmlException(); } XmlReaderHelper.SkipAllSiblings(reader); // xs:any reader.ReadEndElement(); // Metadata }
private bool _GetToken(XmlReader reader, out string strToken) { bool fResult = reader.IsStartElement(); strToken = fResult ? reader.LocalName : null; return fResult; }
/// <summary> /// Load the DOM tree from the Open XML part. /// </summary> /// <param name="openXmlPart">The part this root element to be loaded from.</param> /// <param name="partStream">The stream of the part.</param> /// <returns> /// Returns true when the part stream is loaded successfully into this root element. /// Returns false when the part stream does not contain any xml element. /// </returns> /// <exception cref="InvalidDataException">Thrown when the part stream contains an incorrect root element.</exception> internal bool LoadFromPart(OpenXmlPart openXmlPart, Stream partStream) { Profiler.CommentMarkProfile(Profiler.MarkId.OpenXmlPartRootElement_LoadFromPart_In); if (partStream.Length < 4) { // The XmlReader.Read() method requires at least four bytes from the data stream in order to begin parsing. return(false); } // set MaxCharactersInDocument to limit the part size on loading DOM. this.OpenXmlElementContext.XmlReaderSettings.MaxCharactersInDocument = openXmlPart.MaxCharactersInPart; this.OpenXmlElementContext.XmlReaderSettings.DtdProcessing = DtdProcessing.Prohibit; // set true explicitly for security fix using (XmlReader xmlReader = XmlConvertingReaderFactory.Create(partStream, this.OpenXmlElementContext.XmlReaderSettings, openXmlPart.OpenXmlPackage.StrictTranslation)) { this.OpenXmlElementContext.MCSettings = openXmlPart.MCSettings; xmlReader.Read(); if (xmlReader.NodeType == XmlNodeType.XmlDeclaration) { string standaloneAttribute = xmlReader.GetAttribute("standalone"); if (standaloneAttribute != null) { this._standaloneDeclaration = standaloneAttribute.Equals("yes", StringComparison.OrdinalIgnoreCase); } } if (!xmlReader.EOF) { xmlReader.MoveToContent(); } if (xmlReader.EOF || XmlNodeType.Element != xmlReader.NodeType || !xmlReader.IsStartElement()) { //the stream does NOT contains any xml element. return(false); } byte nsId; if (!NamespaceIdMap.TryGetNamespaceId(xmlReader.NamespaceURI, out nsId) || nsId != this.NamespaceId || xmlReader.LocalName != this.LocalName) { string elementQName = new XmlQualifiedName(xmlReader.LocalName, xmlReader.NamespaceURI).ToString(); string msg = String.Format(System.Globalization.CultureInfo.CurrentUICulture, ExceptionMessages.Fmt_PartRootIsInvalid, elementQName, this.XmlQualifiedName.ToString()); throw new InvalidDataException(msg); } // remove all children and clear all attributes this.OuterXml = string.Empty; var mcContextPushed = this.PushMcContext(xmlReader); this.Load(xmlReader, this.OpenXmlElementContext.LoadMode); if (mcContextPushed) { this.PopMcContext(); } } Profiler.CommentMarkProfile(Profiler.MarkId.OpenXmlPartRootElement_LoadFromPart_Out); return(true); }
public override bool CanReadToken(XmlReader reader) => reader?.IsStartElement("UsernameToken", WsSecurityConstants.WsSecurity10.Namespace) == true;
/* Method to extract the client specific parts of the config file */ private bool ExtractClientConfig(XmlReader reader) { try { while (reader.Read()) { if (reader.IsStartElement()) { if (reader.Name == "client") { client_config.Add(new ClientConfig()); while (reader.MoveToNextAttribute()) { if (reader.Name == "name") client_config.Last().name.Add("short_name", reader.Value); else if (reader.Name == "lname") client_config.Last().name.Add("full_name", reader.Value); else Console.WriteLine("Unknown report configuration attribute: " + reader.Name); } } else if (reader.Name == "project") client_config.Last().projects.Add(reader.ReadString()); else if (reader.Name == "priority") client_config.Last().priority.Add(reader.ReadString()); else if (reader.Name == "email") client_config.Last().email.Add(reader.ReadString()); } } return true; } catch (Exception ex) { Console.WriteLine("Exception when extracting client data from config XML: " + ex.Message); return false; } }