private void expandNamespace_namespace(TreeNodeCollection outNodes, TreeNode outInstanceMethods, string strSection, string strNamespace, XmlReader reader)
{
bool bContinue = reader.ReadToDescendant("namespace");
while (bContinue)
{
if (reader.GetAttribute("name") == strNamespace)
{
expandNamespace_function(outNodes, outInstanceMethods, strSection, strNamespace, reader.ReadSubtree());
reader.Close();
return;
}
bContinue = ReadToNextSibling(reader, "namespace");
}
reader.Close();
}
private XmlDocument ReadXMLDocument()
{
System.Xml.XmlDocument Doc = new System.Xml.XmlDocument();
MemoryStream Buffer = default(MemoryStream);
System.Xml.XmlReader XMLReader = default(System.Xml.XmlReader);
byte B = 0;
Buffer = new MemoryStream();
do
{
B = pReader.ReadByte();
if (B == 0)
{
break;
}
Buffer.WriteByte(B);
}while (true);
Buffer.Flush();
Buffer.Seek(0, SeekOrigin.Begin);
XMLReader = System.Xml.XmlReader.Create(Buffer, pXMLSettings);
Doc.Load(XMLReader);
XMLReader.Close();
return(Doc);
}
public bool Load(string FileName)
{
if (!File.Exists(FileName)) return false;
if ((new FileInfo(FileName).Length) == 0)
{
File.Delete(FileName);
return false;
}
F = XmlReader.Create(FileName);
try
{
F.MoveToContent();
}
catch (Exception)
{
F.Close();
File.Delete(FileName);
return false;
}
return true;
}
void ReadResults(XmlReader reader)
{
CodeCoverageModule currentModule = null;
CodeCoverageMethod currentMethod = null;
string currentClassName = String.Empty;
while (reader.Read()) {
switch (reader.NodeType) {
case XmlNodeType.Element:
if (reader.Name == "Type") {
currentModule = AddModule(reader);
currentClassName = reader.GetAttribute("name");
} else if ((reader.Name == "Method") && (currentModule != null)) {
currentMethod = AddMethod(currentModule, currentClassName, reader);
} else if ((reader.Name == "pt") && (currentMethod != null)) {
AddSequencePoint(currentMethod, reader);
} else if (reader.Name == "File") {
AddFileName(reader);
} else if (reader.Name == "Assembly") {
AddAssembly(reader);
}
break;
}
}
reader.Close();
}
/// <summary>
/// Executes an XMLA command on the tabular model for the connection.
/// </summary>
/// <param name="server"></param>
/// <param name="commandStatement"></param>
/// <returns>XmlNodeList containing results of the command execution.</returns>
public static XmlNodeList ExecuteXmlaCommand(Microsoft.AnalysisServices.Core.Server server, string catalog, string commandStatement, ref bool foundFault)
{
XmlWriter xmlWriter = server.StartXmlaRequest(XmlaRequestType.Undefined);
WriteSoapEnvelopeWithCommandStatement(xmlWriter, server.SessionID, catalog, commandStatement);
System.Xml.XmlReader xmlReader = server.EndXmlaRequest();
xmlReader.MoveToContent();
string fullEnvelopeResponseFromServer = xmlReader.ReadOuterXml();
xmlReader.Close();
XmlDocument documentResponse = new XmlDocument();
documentResponse.LoadXml(fullEnvelopeResponseFromServer);
XmlNamespaceManager nsmgr = new XmlNamespaceManager(documentResponse.NameTable);
nsmgr.AddNamespace("myns1", "urn:schemas-microsoft-com:xml-analysis");
nsmgr.AddNamespace("myns2", "urn:schemas-microsoft-com:xml-analysis:rowset");
XmlNodeList rows = documentResponse.SelectNodes("//myns1:ExecuteResponse/myns1:return/myns2:root/myns2:row", nsmgr);
if (rows.Count == 0 && documentResponse.GetElementsByTagName("faultcode").Count > 0)
{
foundFault = true;
}
return(rows);
}
XDocument settings; //xml settings document
#endregion Fields
#region Constructors
public DataHandler()
{
//instantiate lists
history = new History();
bookmarks = new Bookmarks();
//set path to user.home
path = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile) + "\\settings.xml";
//Read xml from user home, if no document exist, skip
try
{
reader = XmlTextReader.Create(@path);
settings = XDocument.Load(reader);
//create objects and lists from xml
loadBookmarks();
loadHistory();
loadHomePage();
reader.Close();
}
catch (FileNotFoundException)
{
//skip this step
}
}
void ReadResults(XmlReader reader)
{
CodeCoverageModule currentModule = null;
CodeCoverageMethod currentMethod = null;
string currentClassName = String.Empty;
while (reader.Read()) {
switch (reader.NodeType) {
case XmlNodeType.Element:
if (reader.Name == "Type") {
currentModule = AddModule(reader);
currentClassName = reader.GetAttribute("name");
} else if ((reader.Name == "Method") && (currentModule != null) && (!reader.IsEmptyElement)) {
currentMethod = AddMethod(currentModule, currentClassName, reader);
} else if ((reader.Name == "pt") && (currentMethod != null)) {
AddSequencePoint(currentMethod, reader);
} else if (reader.Name == "File") {
AddFileName(reader);
} else if (reader.Name == "Assembly") {
AddAssembly(reader);
}
break;
case XmlNodeType.EndElement:
if (currentMethod != null && reader.Name == "Method" && currentMethod.SequencePoints.Count == 0) {
// Remove method that has no sequence points.
currentModule.Methods.Remove(currentMethod);
}
break;
}
}
reader.Close();
RemoveModulesWithNoMethods();
}
public string Task1()
{
reader = XmlReader.Create(FILE_NAME);
decimal in_v = 0;
decimal out_v = 0;
while (reader.Read())
{
if (reader.IsStartElement())
{
switch (reader.Name)
{
case IN_V:
if(reader.Read())
in_v += Convert.ToDecimal(reader.Value.Trim());
break;
case OUT_V:
if (reader.Read())
out_v += Convert.ToDecimal(reader.Value.Trim());
break;
}
}
}
reader.Close();
return IN_V + in_v.ToString() + "\n" + OUT_V + out_v.ToString();
}
private void updateLastPost()
{
reader = XmlReader.Create(URL);
SyndicationFeed feed = SyndicationFeed.Load(reader);
reader.Close();
lastPost = feed.Items.First();
}
public ApiResponse <T> ReadXml <T>(string fileName)
{
var response = new ApiResponse <T>();
string fileSysName = fileName;
FileStream fs = null;
System.Xml.XmlReader reader = null;
//---------------------------------------------------------------------
try
{
fs = new FileStream(fileSysName, FileMode.Open, FileAccess.Read, FileShare.Read);
reader = XmlReader.Create(fs);
var serializer = new System.Xml.Serialization.XmlSerializer(typeof(T)); //todo use DI for serializer
var obj = serializer.Deserialize(reader);
response.Data = (T)obj;
}
catch (Exception e)
{
response.Status.SetError(-1, "Xml error reading/deserializing file: " + fileSysName, e);
}
finally
{
reader?.Close();
fs?.Close();
}
return(response);
}
static XmlDocument ParseTextAssetToXMLDocument(TextAsset textasset)
{
XmlDocument xmlDoc = new XmlDocument();
//because of annoying feature of Unity, that the way to read UTF-8 XML, we need to skip BOM(byte order mark)
//but for XML without UTF-8 character, we MUST NOT skip first character.
//so, we firstly not skip BOM, try to load XML, if it fail, then try skip BOM to parse again.
bool parseOK = false;
//1. not SKIP first character
try
{
xmlDoc.LoadXml(textasset.text);
parseOK = true;
return(xmlDoc);
}
catch (System.Exception exc)
{
Debug.Log("It seems we need to skip BOM at XML:" + textasset.name + "\n" + exc.StackTrace);
parseOK = false;
}
//if 1. fail, skip BOM, and parse again.
if (parseOK == false)
{
System.IO.StringReader stringReader = new System.IO.StringReader(textasset.text);
stringReader.Read(); // skip BOM
System.Xml.XmlReader reader = System.Xml.XmlReader.Create(stringReader);
xmlDoc.Load(reader);
reader.Close();
stringReader.Close();
}
return(xmlDoc);
}
private void expandNamespace_function(TreeNodeCollection outNodes, string strSection, string strNamespace, XmlReader reader)
{
bool bContinue = reader.ReadToDescendant("function");
while (bContinue)
{
NodeDocPythonFunction node = newnode(strSection, strNamespace, reader.GetAttribute("name"));
outNodes.Add(node);
bool bInstance = reader.GetAttribute("instance") == "true";
node.bIsInstanceMethod = bInstance;
string strSyntax = reader.GetAttribute("fullsyntax"); if (strSyntax != null && strSyntax != "") node.strFullSyntax = strSyntax;
node.strDocumentation = getFunctionDocAndExample(reader.ReadSubtree()); //assumes doc before example
if (this.emphasizeStaticness())
{
if (!bInstance)
{
//change visible node text to emphasize static-ness
node.Text = node.strNamespacename + "." + node.strFunctionname;
}
}
bContinue = ReadToNextSibling(reader, "function");
}
reader.Close();
}
internal Disc (XmlReader reader)
{
reader.Read ();
int.TryParse (reader ["sectors"], out sectors);
id = reader ["id"];
reader.Close ();
}
private void expandNamespace_function(TreeNodeCollection outNodes, TreeNode outInstanceMethods, string strSection, string strNamespace, XmlReader reader)
{
bool bContinue = reader.ReadToDescendant("function");
while (bContinue)
{
// if (reader.GetAttribute("args") != null) MessageBox.Show("instance?");
NodeDocLnzFunction node = new NodeDocLnzFunction(strSection, strNamespace, reader.GetAttribute("name"));
bool bInstance = reader.GetAttribute("instance") == "true";
node.bIsInstanceMethod = bInstance;
string strArgs = reader.GetAttribute("args"); if (strArgs != null && strArgs != "") node.strArguments = strArgs;
string strReturns = reader.GetAttribute("returns"); if (strReturns != null && strReturns != "") node.strReturns = strReturns;
node.strDocumentationAndExample = getFunctionDocAndExample(reader.ReadSubtree()); //assumes doc before example
if (bInstance)
{
//MessageBox.Show("instance found");
outInstanceMethods.Nodes.Add(node);
}
else
outNodes.Add(node);
bContinue = ReadToNextSibling(reader, "function");
}
reader.Close();
}
/// <summary>
/// Parses the specified reader.
/// </summary>
/// <param name="reader">The reader.</param>
/// <returns></returns>
public override T Parse <T>(System.Xml.XmlReader reader)
{
// Need a specific parser
IParser subparser = null;
IFeed ret = null;
string localRootName = reader.LocalName.ToLower().Trim();
if (localRootName == "rss" || localRootName == "rdf")
{
subparser = new RssFeedParser();
}
else if (localRootName == "feed")
{
subparser = new AtomFeedParser();
}
if (subparser != null)
{
using (XmlReader subreader = reader.ReadSubtree())
{
ret = (IFeed)subparser.Parse <T>(subreader);
}
}
else
{
throw new Exception(string.Format("Unknown feed type '{0}'.", reader.Name));
}
reader.Close();
return((T)ret);
}
private static void ReadXmlSerializable(DataTable dt, XmlReader xr)
{
XmlSerializer serializer = new XmlSerializer(dt.GetType());
IXmlSerializable idt = dt;
idt.ReadXml(xr);
xr.Close();
}
private string ReadOuterXml(XmlReader forReader) {
try {
forReader.MoveToContent();
return forReader.ReadOuterXml();
} finally {
forReader.Close();
}
}
/// <summary>
/// Serializes an object instance to a file.
/// </summary>
/// <param name="instance">the object instance to serialize</param>
/// <param name="resultBuffer">The result buffer.</param>
/// <param name="throwExceptions">if set to <c>true</c> [throw exceptions].</param>
/// <returns></returns>
/// <summary>
/// Serializes an object to an XML string. Unlike the other SerializeObject overloads
/// this methods *returns a string* rather than a bool result!
/// </summary>
/// <param name="instance"></param>
/// <param name="throwExceptions">Determines if a failure throws or returns null</param>
/// <returns>
/// null on error otherwise the Xml String.
/// </returns>
/// <remarks>
/// If null is passed in null is also returned so you might want
/// to check for null before calling this method.
/// </remarks>
/// <summary>
/// Deserializes an object from file and returns a reference.
/// </summary>
/// <param name="fileName">name of the file to serialize to</param>
/// <param name="objectType">The Type of the object. Use typeof(yourobject class)</param>
/// <param name="binarySerialization">determines whether we use Xml or Binary serialization</param>
/// <returns>Instance of the deserialized object or null. Must be cast to your object type</returns>
/// <summary>
/// Deserializes an object from file and returns a reference.
/// </summary>
/// <param name="fileName">name of the file to serialize to</param>
/// <param name="objectType">The Type of the object. Use typeof(yourobject class)</param>
/// <param name="binarySerialization">determines whether we use Xml or Binary serialization</param>
/// <param name="throwExceptions">determines whether failure will throw rather than return null on failure</param>
/// <returns>Instance of the deserialized object or null. Must be cast to your object type</returns>
/// <summary>
/// Deserialize an object from an XmlReader object.
/// </summary>
/// <param name="reader"></param>
/// <param name="objectType"></param>
/// <returns></returns>
public static object DeSerializeObject(XmlReader reader, Type objectType)
{
var serializer = new XmlSerializer(objectType);
var instance = serializer.Deserialize(reader);
reader.Close();
return instance;
}
/// <exclude />
public void Compile(XmlReader reader, IFormChannelIdentifier channel,
Dictionary<string, object> bindingObjects, bool withDebug, string customControlIdPrefix,
Dictionary<string, List<ClientValidationRule>> bindingsValidationRules)
{
XDocument doc = XDocument.Load(reader);
reader.Close();
Compile(doc, channel, bindingObjects, withDebug, customControlIdPrefix, bindingsValidationRules);
}
protected override void DeserializePropertyElement(XmlReader reader)
{
if (reader.Name.ToLower () == "optional") {
optional = true;
reader.Close ();
} else {
base.DeserializePropertyElement (reader);
}
}
/// <summary>
/// Deserialize an object from an XmlReader object.
/// </summary>
/// <param name="reader"></param>
/// <param name="ObjectType"></param>
/// <returns></returns>
public static object DeSerializeObject(System.Xml.XmlReader reader, Type ObjectType)
{
XmlSerializer serializer = new XmlSerializer(ObjectType);
object Instance = serializer.Deserialize(reader);
reader.Close();
return(Instance);
}
public override void Close()
{
if (!Settings.KeepOpen)
{
if (reader != null)
{
reader.Close();
}
}
}
private void ProcessDataReader(XmlReader reader)
{
ResultsListBox.Items.Clear();
while (reader.Read())
{
ResultsListBox.Items.Add(reader.ReadOuterXml());
//MessageBox.Show(reader.ReadOuterXml());
}
reader.Close();
}
/// <summary>
/// Parse the data from specified Uri into a document.
/// </summary>
/// <param name="document">The document instance to store the gained data in.</param>
/// <param name="xmlTextReader">XmlTextReader instance</param>
protected virtual void Parse(OpmlDocument document, System.Xml.XmlReader xmlTextReader)
{
try
{
System.Diagnostics.Debug.Assert(xmlTextReader != null);
//
xmlTextReader.MoveToContent();
if (xmlTextReader.Name != "opml")
{
throw new FormatException(xmlTextReader.BaseURI + " is no valid Opml File");
}
// read the stream forward while not end of file
int currentDepth = -1;
System.Collections.Hashtable nodeLevels = new System.Collections.Hashtable();
//
while (!xmlTextReader.EOF)
{
// process head
if (xmlTextReader.Name == "head" && xmlTextReader.NodeType == XmlNodeType.Element)
{
document.Head = new OpmlHead(xmlTextReader);
}
// process outline and child outlines
else if (xmlTextReader.Name == "outline" && xmlTextReader.NodeType == XmlNodeType.Element)
{
currentDepth = xmlTextReader.Depth;
//
OpmlOutline o = OnCreateOutline(xmlTextReader);
if (currentDepth == 2)
{
document.Body.Items.Add(o);
// new node
nodeLevels.Clear();
}
else
{
((OpmlOutline)nodeLevels[xmlTextReader.Depth - 1]).Items.Add(o);
}
nodeLevels[xmlTextReader.Depth] = o;
}
else
{
xmlTextReader.Read();
xmlTextReader.MoveToContent();
}
}
}
finally
{
if (xmlTextReader != null)
{
xmlTextReader.Close();
}
}
}
/// <summary>
/// 反序列化Xml
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="targetFile"></param>
/// <returns></returns>
public T XmlFileDeserialize <T>(string targetFile)
{
System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(typeof(T));
StringBuilder sb = new StringBuilder();
System.Xml.XmlReader reader = System.Xml.XmlReader.Create(targetFile);
object deobj = serializer.Deserialize(reader);
reader.Close();
return((T)deobj);
}
protected override void DeserializePropertyElement(XmlReader reader)
{
if (reader.Name.ToLower () == "optional") {
IsOptional = true;
reader.Close ();
} else if (reader.Name.ToLower () == "sendeventsattribute") {
SendsEvents = reader.ReadString ().Trim () == "yes";
} else {
base.DeserializePropertyElement (reader);
}
}
protected string getFunctionDocAndExample(XmlReader reader)
{
//assumes doc is before example. Otherwise, could miss an example.
string strRes = "";
bool bFound = reader.ReadToDescendant("doc");
if (bFound) strRes += (unencodeXml(reader.ReadString()));
bFound = reader.ReadToNextSibling("example");
if (bFound) strRes += ("\r\n\r\nExample:\r\n" + unencodeXml(reader.ReadString()));
reader.Close();
return strRes;
}
public static List <T> DeserializeParams <T>(XDocument doc)
{
System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(typeof(List <T>));
System.Xml.XmlReader reader = doc.CreateReader();
List <T> result = (List <T>)serializer.Deserialize(reader);
reader.Close();
return(result);
}
/// <summary>
/// 反序列化xml
/// </summary>
/// <typeparam name="t"></typeparam>
/// <param name="targetfile"></param>
/// <returns></returns>
public T XmlDeserialize <T>(string xml)
{
System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(typeof(T));
System.IO.MemoryStream stream = new System.IO.MemoryStream(Encoding.UTF8.GetBytes(xml));
System.Xml.XmlReader reader = System.Xml.XmlReader.Create(stream);
object deobj = serializer.Deserialize(reader);
reader.Close();
stream.Close();
return((T)deobj);
}
protected XDocument ExecuteDVMQuery(Server server, string query)
{
System.Xml.XmlWriter xmlWriter = server.StartXmlaRequest(XmlaRequestType.Undefined);
WriteDVMEnvelope(xmlWriter, query);
System.Xml.XmlReader xmlReader = server.EndXmlaRequest();
xmlReader.MoveToContent();
XDocument doc = XDocument.Load(xmlReader);
xmlReader.Close();
return(doc);
}
public ISMStream(Stream stream)
{
ISMElement ismElement = null;
try {
xmlReader = XmlReader.Create(stream);
// crude parser
while (xmlReader.Read()) {
if (xmlReader.NodeType != XmlNodeType.Element) {
continue;
}
if (xmlReader.Name == "audio" || xmlReader.Name == "video") {
// ismElement MUST be null at this point
if (ismElement != null)
throw new Exception("ISMFile: time scale param not found");
ismElement = new ISMElement();
if (xmlReader.Name == "audio") {
ismElement.FragmentType = FragmentType.Audio;
}
else if (xmlReader.Name == "video") {
ismElement.FragmentType = FragmentType.Video;
}
ismElement.Source = xmlReader.GetAttribute("src");
ismElement.Bitrate = long.Parse(xmlReader.GetAttribute("systemBitrate"));
}
else if (xmlReader.Name == "param")
{
string paramName = xmlReader.GetAttribute("name");
string attributeValue = xmlReader.GetAttribute("value");
if (paramName == "trackID")
{
ismElement.TrackID = int.Parse(attributeValue);
}
else if (paramName == "timeScale")
{
ismElement.TimeScale = uint.Parse(attributeValue);
ismElements.Add(ismElement);
ismElement = null;
}
}
}
} catch {
throw;
} finally {
if (xmlReader != null) {
xmlReader.Close();
}
}
}
private XPathDocument CreateAndCacheDocument(XmlReader r)
{
string uri = r.BaseURI;
XPathDocument doc = new XPathDocument(r, XmlSpace.Preserve);
r.Close();
lock (_cache)
{
if (!_cache.ContainsKey(uri))
_cache.Add(uri, new WeakReference(doc));
}
return doc;
}
internal Event(XmlReader reader)
{
reader.Read ();
date = reader ["date"];
country = reader ["country"];
catalog_number = reader ["catalog-number"];
barcode = reader ["barcode"];
format = Utils.StringToEnum<ReleaseFormat> (reader ["format"]);
if (reader.ReadToDescendant ("label")) {
label = new Label (reader.ReadSubtree ());
reader.Read (); // FIXME this is a workaround for Mono bug 334752
}
reader.Close ();
}
private static bool EsCFDIXmlValido(List <String> PathsXSD, System.IO.StringReader XMLPath, out List <string> Errores)
{
try
{
// 0- Initialize variables...
_IsValid = true;
Resultado = new List <string>();
// 1- Read XML file content
Reader = new System.Xml.XmlTextReader(XMLPath);
// 3- Create a new instance of XmlSchema object
System.Xml.Schema.XmlSchema Schema = new System.Xml.Schema.XmlSchema();
System.Xml.XmlReaderSettings ReaderSettings = new System.Xml.XmlReaderSettings();
// 2- Read Schema file content
foreach (String XSD in PathsXSD)
{
StreamReader SR = new StreamReader(XSD);
Schema = System.Xml.Schema.XmlSchema.Read(SR, new System.Xml.Schema.ValidationEventHandler(ReaderSettings_ValidationEventHandler));
ReaderSettings.ValidationType = System.Xml.ValidationType.Schema;
ReaderSettings.Schemas.Add(Schema);
}
// 8- Add your ValidationEventHandler address to
// XmlReaderSettings ValidationEventHandler
ReaderSettings.ValidationEventHandler += new System.Xml.Schema.ValidationEventHandler(ReaderSettings_ValidationEventHandler);
// 9- Create a new instance of XmlReader object
System.Xml.XmlReader objXmlReader = System.Xml.XmlReader.Create(Reader, ReaderSettings);
// 10- Read XML content in a loop
while (objXmlReader.Read())
{
// empty loop
}
// Se cierra el validador
objXmlReader.Close();
Errores = Resultado;
return(_IsValid);
}
catch (Exception ex)
{
Errores = new List <string>();
Errores.Add("Error de validacion del XML Error:" + ex.ToString());
return(true);
}
}
private void btnConvert_Click(object sender, EventArgs e)
{
scale = float.Parse(txtScale.Text, NumberFormatInfo);
worldsize = float.Parse(txtWorldSize.Text, NumberFormatInfo);
x = float.Parse(txtX.Text, NumberFormatInfo);
z = float.Parse(txtZ.Text, NumberFormatInfo);
XmlWriterSettings settings = new XmlWriterSettings();
settings.Indent = true;
settings.IndentChars = " ";
Log("Creating nodes.xml");
writer = XmlWriter.Create("nodes.xml", settings);
// write
writer.WriteStartDocument();
writer.WriteStartElement("nodes");
writer.WriteAttributeString("count", "0");
// process grass
Log("Reading " + txtGrassFilename.Text);
reader = XmlReader.Create(txtGrassFilename.Text);
int grassnodes = ConvertGrass(reader, writer);
reader.Close();
Log("Exported " + grassnodes + " grassnodes.");
// process trees
Log("Reading " + txtTreeFilename.Text);
reader = XmlReader.Create(txtTreeFilename.Text);
int treenodes = ConvertTrees(reader, writer);
reader.Close();
Log("Exported " + treenodes + " treenodes.");
// end
writer.WriteEndElement();
writer.WriteEndDocument();
writer.Close();
int sum = grassnodes + treenodes;
Log("Sum: " + sum.ToString() + " nodes.");
// replace count
Log("Replacing count in nodes.xml");
string s = System.IO.File.ReadAllText("nodes.xml");
System.IO.File.WriteAllText("nodes.xml", s.Replace("count=\"0\"", "count=\"" + sum + "\""));
Log("Export finished.");
}
public static T ExecuteXmlCommand <T>(SqlCommand sqlCommand, DataLocationEnum dataLocation)
{
string connectionString = GetSqlConnectionString(dataLocation);
using (SqlConnection cn = new SqlConnection(connectionString))
{
cn.Open();
sqlCommand.Connection = cn;
System.Xml.XmlReader xmlReader = sqlCommand.ExecuteXmlReader();
T item = YellowstonePathology.Business.Domain.Persistence.SerializationHelper.DeserializeItem <T>(xmlReader);
xmlReader.Close();
return(item);
}
}
//public static string HostAddress
//{
// get
// {
// foreach (IPAddress address in Dns.GetHostAddresses (Dns.GetHostName ())) {
// if (address.AddressFamily == AddressFamily.InterNetwork) {
// return address;
// }
// }
// }
//}
public static Version DeserializeSpecVersion(XmlReader reader)
{
try {
// We assume the elements appear in this order
reader.ReadToFollowing ("major");
reader.Read ();
var major = reader.ReadContentAsInt ();
reader.ReadToFollowing ("minor");
reader.Read ();
var minor = reader.ReadContentAsInt ();
return new Version (major, minor);
} catch (Exception e) {
throw new UpnpDeserializationException ("There was a problem deserializing a spec version.", e);
} finally {
reader.Close ();
}
}
private XPathDocument CreateAndCacheDocument(XmlReader r)
{
string uri = r.BaseURI;
XPathDocument doc = new XPathDocument(r, XmlSpace.Preserve);
r.Close();
//Can't cache documents with empty base URI
if (!string.IsNullOrEmpty(uri))
{
lock (_cache)
{
if (!_cache.ContainsKey(uri))
_cache.Add(uri, new WeakReference(doc));
}
}
return doc;
}
/// <summary>
/// Parses the specified reader.
/// </summary>
/// <param name="reader">The reader.</param>
/// <returns></returns>
public override T Parse <T>(System.Xml.XmlReader reader)
{
IOpmlFeed ret = new OpmlFeed();
bool readContent = false;
while (readContent || reader.Read())
{
readContent = false;
if (reader.NodeType == XmlNodeType.Element)
{
readContent = true;
switch (reader.Name)
{
case "head":
using (XmlReader subReader = reader.ReadSubtree())
{
ret.Head = ConvertToIOpmlHead(subReader);
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
case "body":
using (XmlReader subReader = reader.ReadSubtree())
{
ret.Body = ConvertToIOpmlBody(subReader);
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
default:
UnhandledElement(ret, reader);
break;
}
}
}
reader.Close();
return((T)ret);
}
/// <summary>
/// Releases the unmanaged resources used by the ComponentLibrary and optionally releases the managed resources.
/// </summary>
/// <param name="disposing">true to release both managed and unmanaged resources; false to release only unmanaged resources.</param>
private void Dispose(bool disposing)
{
if (!this._disposed)
{
if (disposing)
{
_xmlReader.Close();
_input.Close();
if (_ownsInputStream)
{
_input.Dispose();
}
}
_disposed = true;
}
}
//RETORNA TABELA NO FORMATO DE STRING XML
public string ReturnStrXml()
{
string strXml = "";
try
{
DateTime datStart = DateTime.Now;
if (this._XmlCmd == null)
{
SetConn();
GenericCLX.CS.Util objUtil = new GenericCLX.CS.Util();
//objUtil.GetConfig("");
_XmlCmd = new SqlXmlCommand(objUtil.ConnectionStringXML());
_XmlCmd.OutputEncoding = "ISO-8859-1";
_XmlCmd.RootTag = "ROOT";
}
_XmlCmd.CommandText = this._Sql;
System.Xml.XmlReader objXr = _XmlCmd.ExecuteXmlReader();
XmlDocument objXd = new XmlDocument();
objXd.Load(objXr);
strXml = objXd.OuterXml;
objXd = null;
objXr.Close();
objXr = null;
if (this._CloseConn)
{
_XmlCmd = null;
}
this._TimeQuery = Functions.DateDiff(datStart.ToLocalTime().ToString());
}
catch (Exception e)
{
if (TreatedError(e.Message))
{
this.ReturnStrXml();
}
}
return(strXml);
}
private static XDocument StartAndEndXmlaRequest(Server server, string query)
{
// Step 1: start the XML/A request.
System.Xml.XmlWriter xmlWriter = server.StartXmlaRequest(XmlaRequestType.Undefined);
// Step 2: write the XML/A request.
WriteSoapEnvelope(xmlWriter, query);
// Step 3: end the XML/A request and get the System.Xml.XmlReader for parsing the result from server.
System.Xml.XmlReader xmlReader = server.EndXmlaRequest();
// Step 4: read/parse the XML/A response from server.
xmlReader.MoveToContent();
XDocument doc = XDocument.Load(xmlReader);
// Step 5: close the System.Xml.XmlReader, to release the connection for future use.
xmlReader.Close();
return(doc);
}
public static List <T> DeserializeParamsListOf <T>(string xmlFilename)
{
List <T> result;
XDocument xdoc = XDocument.Load(xmlFilename);
try
{
System.Xml.Serialization.XmlSerializer serializer =
new System.Xml.Serialization.XmlSerializer(typeof(List <T>));
System.Xml.XmlReader reader = xdoc.CreateReader();
result = (List <T>)serializer.Deserialize(reader);
reader.Close();
}
finally
{
}
return(result);
}
public void post(Subreddit subreddit)
{
reader = XmlReader.Create(URL);
SyndicationFeed feed = SyndicationFeed.Load(reader);
reader.Close();
foreach (SyndicationItem item in feed.Items)
{
if(item.Title.Text == lastPost.Title.Text)
{
break;
}
else
{
try
{
postItem(item, subreddit);
}
catch (Exception) { }
}
}
}
protected XDocument WriteDiscoverSchemaQuery(Server server, string type)
{
System.Xml.XmlWriter xmlWriter = server.StartXmlaRequest(XmlaRequestType.Undefined);
xmlWriter.WriteStartElement("Envelope", "http://schemas.xmlsoap.org/soap/envelope/");
xmlWriter.WriteStartElement("Body");
xmlWriter.WriteStartElement("Discover", "urn:schemas-microsoft-com:xml-analysis");
xmlWriter.WriteElementString("RequestType", type);
xmlWriter.WriteStartElement("Restrictions");
xmlWriter.WriteEndElement(); // </Restrictions>
xmlWriter.WriteStartElement("Properties");
xmlWriter.WriteEndElement(); // </Properties>
xmlWriter.WriteEndElement(); // </Discover>
xmlWriter.WriteEndElement(); // </Body>
xmlWriter.WriteEndElement(); // </Envelope>
System.Xml.XmlReader xmlReader = server.EndXmlaRequest();
xmlReader.MoveToContent();
XDocument doc = XDocument.Load(xmlReader);
xmlReader.Close();
return(doc);
}
//The Sum operation operates on the WCF Message object directly
public Message Sum(Message request)
{
int sum = 0;
string text = "";
//The body of the message contains a list of numbers which will be read directly using an XmlReader
System.Xml.XmlReader body = request.GetReaderAtBodyContents();
while (body.Read())
{
text = body.ReadString().Trim();
if (text.Length > 0)
{
sum += Convert.ToInt32(text, CultureInfo.InvariantCulture);
}
}
body.Close();
Message response = Message.CreateMessage(request.Version, "http://Microsoft.Samples.XmlReader/ICalculator/SumResponse", sum);
return(response);
}
public static Manifest Create(XmlReader reader)
{
if (reader == null)
{
throw new ArgumentNullException("reader");
}
var configurationNode = new Manifest();
// no attributes on the root node; just process child elements
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.Name)
{
case ArgumentsElementName:
ReadArgumentsElement(reader.ReadSubtree(), configurationNode.DefaultArguments);
break;
case OutputElementName:
configurationNode.Outputs.Add(ReadOutputElement(reader.ReadSubtree()));
break;
case RenameElementName:
ReadRenameElement(reader.ReadSubtree(), configurationNode.RenameIdentifiers);
break;
case NoRenameElementName:
ReadNoRenameElement(reader.ReadSubtree(), configurationNode.NoRenameIdentifiers);
break;
}
}
}
reader.Close();
return configurationNode;
}
/// <summary>
/// Pretty prints XML document using XmlWriter's formatting functionality.
/// </summary>
/// <param name="reader">Source XML reader</param>
/// <param name="options">Parsed command line options</param>
public static void PrettyPrint(XmlReader reader, NXsltOptions options)
{
XmlWriterSettings writerSettings = new XmlWriterSettings();
writerSettings.Indent = true;
writerSettings.NewLineOnAttributes = true;
writerSettings.Encoding = new UTF8Encoding(false);
XmlWriter writer;
if (options.OutFile != null)
{
//Pretty print to a file
writer = XmlWriter.Create(options.OutFile, writerSettings);
}
else
{
//Pretty print to the console
writer = XmlWriter.Create(Console.Out, writerSettings);
}
while (reader.ReadState != ReadState.EndOfFile)
{
writer.WriteNode(reader, false);
}
writer.Close();
reader.Close();
}
public async Task <HttpResponseMessage> PostRawBufferManual()
{
string connStr = "";
string loc = "";
try
{
string request = await Request.Content.ReadAsStringAsync();
var addin = Globals.ThisAddIn;
var app = addin.Application;
var wb = app.ActiveWorkbook;
loc = wb.FullName; //@"D:\Data\Presentations\Drop Your DAX\demos\02 DAX filter similar.xlsx";
// parse request looking for workbook name in Workstation ID
// we are using the Workstation ID property to tunnel the location property through
// from the UI to the PowerPivot engine. The Location property does not appear to get
// serialized through into the XMLA request so we "hijack" the Workstation ID
var wsid = ParseRequestForWorkstationID(request);
if (!string.IsNullOrEmpty(wsid))
{
Log.Debug("{class} {method} {message}", "XmlaController", "PostRawBufferManual", "Resetting Location based on WorkstationID to: " + loc);
loc = wsid;
}
connStr = string.Format("Provider=MSOLAP;Persist Security Info=True;Initial Catalog=Microsoft_SQLServer_AnalysisServices;Data Source=$Embedded$;MDX Compatibility=1;Safety Options=2;MDX Missing Member Mode=Error;Subqueries=0;Optimize Response=7;Location=\"{0}\"", loc);
//connStr = string.Format("Provider=MSOLAP;Persist Security Info=True;Data Source=$Embedded$;MDX Compatibility=1;Safety Options=2;MDX Missing Member Mode=Error;Subqueries=0;Optimize Response=7;Location={0}", loc);
// 2010 conn str
//connStr = string.Format("Provider=MSOLAP.5;Persist Security Info=True;Initial Catalog=Microsoft_SQLServer_AnalysisServices;Data Source=$Embedded$;MDX Compatibility=1;Safety Options=2;ConnectTo=11.0;MDX Missing Member Mode=Error;Optimize Response=3;Cell Error Mode=TextValue;Location={0}", loc);
//connStr = string.Format("Provider=MSOLAP;Data Source=$Embedded$;MDX Compatibility=1;Safety Options=2;ConnectTo=11.0;MDX Missing Member Mode=Error;Optimize Response=3;Location={0};", loc);
Log.Debug("{class} {method} {message}", "XmlaController", "PostRawBufferManual", "About to Load AmoWrapper");
AmoWrapper.AmoType amoType = AmoWrapper.AmoType.AnalysisServices;
if (float.Parse(app.Version, CultureInfo.InvariantCulture) >= EXCEL_2013)
{
amoType = AmoWrapper.AmoType.Excel;
Log.Debug("{class} {method} {message}", "XmlaController", "PostRawBufferManual", "Loading Microsoft.Excel.Amo");
}
else
{
Log.Debug("{class} {method} {message}", "XmlaController", "PostRawBufferManual", "defaulting to Microsoft.AnalysisServices");
}
var svr = new AmoWrapper.AmoServer(amoType);
svr.Connect(connStr);
// STEP 1: send the request to server.
Log.Verbose("{class} {method} request: {request}", "XmlaController", "PostRawBufferManual", request);
System.IO.TextReader streamWithXmlaRequest = new StringReader(request);
System.Xml.XmlReader xmlaResponseFromServer = null; // will be used to parse the XML/A response from server
string fullEnvelopeResponseFromServer = "";
try
{
//xmlaResponseFromServer = svr.SendXmlaRequest( XmlaRequestType.Undefined, streamWithXmlaRequest);
xmlaResponseFromServer = svr.SendXmlaRequest(streamWithXmlaRequest);
// STEP 2: read/parse the XML/A response from server.
xmlaResponseFromServer.MoveToContent();
fullEnvelopeResponseFromServer = xmlaResponseFromServer.ReadOuterXml();
}
catch (Exception ex)
{
Log.Error("ERROR sending response: {class} {method} {exception}", "XmlaController", "PostRawBufferManual", ex);
//result = new HttpResponseMessage(HttpStatusCode.InternalServerError);
//result.Content = new StringContent(String.Format("An unexpected error occurred (sending XMLA request): \n{0}", ex.Message));
}
finally
{
streamWithXmlaRequest.Close();
}
HttpResponseMessage result;
try
{
result = new HttpResponseMessage(HttpStatusCode.OK);
result.Content = new StringContent(fullEnvelopeResponseFromServer);
result.Content.Headers.ContentType = new MediaTypeHeaderValue("text/xml");
result.Headers.TransferEncodingChunked = true;
}
catch (Exception ex)
{
Log.Error("ERROR sending response: {class} {method} {exception}", "XmlaController", "PostRawBufferManual", ex);
result = new HttpResponseMessage(HttpStatusCode.InternalServerError);
result.Content = new StringContent(String.Format("An unexpected error occurred (reading XMLA response): \n{0}", ex.Message));
}
finally
{
// STEP 3: close the System.Xml.XmlReader, to release the connection for future use.
if (xmlaResponseFromServer != null)
{
xmlaResponseFromServer.Close();
}
}
return(result);
}
catch (Exception ex)
{
Log.Error("ERROR Connecting: {class} {method} loc: '{loc}' conn:'{connStr}' ex: {exception}", "XmlaController", "PostRawBufferManual", loc, connStr, ex);
var expResult = new HttpResponseMessage(HttpStatusCode.InternalServerError);
expResult.Content = new StringContent(String.Format("An unexpected error occurred: \n{0}", ex.Message));
return(expResult);
}
}
/// <summary>
/// Parses the specified reader.
/// </summary>
/// <param name="reader">The reader.</param>
/// <returns></returns>
public override T Parse <T>(System.Xml.XmlReader reader)
{
IAtomFeed ret = (IAtomFeed) new AtomFeed();
reader.Read();
bool readContent = false;
while (readContent || reader.Read())
{
readContent = false;
if (reader.NodeType == XmlNodeType.Element)
{
readContent = true;
switch (reader.Name)
{
case "id":
ret.FeedUri = CachedPropertiesProvider.ConvertToUri(reader.ReadElementContentAsString(), reader.BaseURI);
break;
case "title":
ret.Title = reader.ReadElementContentAsString();
break;
case "updated":
ret.LastUpdated = CachedPropertiesProvider.ConvertToTzDateTime(reader.ReadElementContentAsString());
break;
case "generator":
using (XmlReader subReader = reader.ReadSubtree())
{
ret.Generator = ConvertToIAtomGenerator(subReader);
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
case "author":
using (XmlReader subReader = reader.ReadSubtree())
{
ret.Authors.Add(ConvertToIAtomPerson(subReader));
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
case "link":
using (XmlReader subReader = reader.ReadSubtree())
{
ret.Links.Add(ConvertToIAtomLink(subReader));
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
case "category":
using (XmlReader subReader = reader.ReadSubtree())
{
ret.Categories.Add(ConvertToIAtomCategory(subReader));
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
case "entry":
using (XmlReader subReader = reader.ReadSubtree())
{
ret.Items.Add(ParseItem(subReader));
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
case "contributor":
using (XmlReader subReader = reader.ReadSubtree())
{
ret.Contributors.Add(ConvertToIAtomPerson(subReader));
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
case "logo":
ret.Logo = reader.ReadElementContentAsString();
break;
case "icon":
ret.Icon = reader.ReadElementContentAsString();
break;
case "rights":
using (XmlReader subReader = reader.ReadSubtree())
{
ret.Rights = ConvertToIAtomText(subReader);
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
case "subtitle":
using (XmlReader subReader = reader.ReadSubtree())
{
ret.Subtitle = ConvertToIAtomText(subReader);
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
default:
UnhandledElement(ret, reader);
break;
}
}
}
reader.Close();
return((T)ret);
}
// Closes the stream, changes the ReadState to Closed, and sets all the properties back to zero.
public override void Close()
{
_coreReader.Close();
_cacheState = CachingReaderState.ReaderClosed;
}
/// <summary>
/// Parses the specified reader.
/// </summary>
/// <param name="reader">The reader.</param>
/// <returns></returns>
public override T Parse <T>(System.Xml.XmlReader reader)
{
IRssFeed ret = (IRssFeed) new RssFeed();
reader.Read();
// RDF versions of RSS don't have version tags.
//double version = double.Parse(reader.GetAttribute("version"));
reader.ReadToDescendant("channel");
bool readContent = false;
while (readContent || reader.Read())
{
readContent = false;
if (reader.NodeType == XmlNodeType.Element)
{
readContent = true;
switch (reader.Name)
{
case "title":
ret.Title = reader.ReadElementContentAsString();
break;
case "link":
ret.FeedUri = CachedPropertiesProvider.ConvertToUri(reader.ReadElementContentAsString());
break;
case "description":
ret.Description = reader.ReadElementContentAsString();
break;
case "language":
ret.Culture = CachedPropertiesProvider.ConvertToCultureInfo(reader.ReadElementContentAsString());
break;
case "copyright":
ret.Copyright = reader.ReadElementContentAsString();
break;
case "managingEditor":
ret.ManagingEditor = reader.ReadElementContentAsString();
break;
case "webMaster":
ret.WebMaster = reader.ReadElementContentAsString();
break;
case "pubDate":
ret.PublicationDate = CachedPropertiesProvider.ConvertToTzDateTime(reader.ReadElementContentAsString());
break;
case "lastBuildDate":
ret.LastChanged = CachedPropertiesProvider.ConvertToTzDateTime(reader.ReadElementContentAsString());
break;
case "category":
using (XmlReader subReader = reader.ReadSubtree())
{
ret.Category = ConvertToIRssCategory(subReader);
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
case "generator":
ret.Generator = reader.ReadElementContentAsString();
break;
case "docs":
ret.Doc = CachedPropertiesProvider.ConvertToUri(reader.ReadElementContentAsString());
break;
case "cloud":
using (XmlReader subReader = reader.ReadSubtree())
{
ret.Cloud = ConvertToIRssCloud(subReader);
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
case "ttl":
ret.TimeToLive = CachedPropertiesProvider.ConvertToInt(reader.ReadElementContentAsString());
break;
case "image":
using (XmlReader subReader = reader.ReadSubtree())
{
ret.Image = ConvertToIRssImage(subReader);
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
/*case "rating":
* break;*/
case "textInput":
using (XmlReader subReader = reader.ReadSubtree())
{
ret.TextInput = ConvertToIRssTextInput(subReader);
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
case "skipHours":
using (XmlReader subReader = reader.ReadSubtree())
{
ret.SkipHours = ConvertToSkipHourList(subReader);
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
case "skipDays":
using (XmlReader subReader = reader.ReadSubtree())
{
ret.SkipDays = ConvertToDayOfWeekList(subReader);
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
case "item":
using (XmlReader itemReader = reader.ReadSubtree())
{
ret.Items.Add(ParseItem(itemReader));
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
default:
UnhandledElement(ret, reader);
break;
}
}
}
reader.Close();
return((T)ret);
}
/*
public static void SaveTemplates ()
{
if (!Directory.Exists (TemplatePath))
Directory.CreateDirectory (TemplatePath);
foreach (string templateFile in Directory.GetFiles (TemplatePath, "*.xml")) {
File.Delete (templateFile);
}
foreach (CodeTemplate template in templates) {
if (string.IsNullOrEmpty (template.Shortcut)) {
LoggingService.LogError ("CodeTemplateService: Can't save unnamed template " + template);
continue;
}
SaveTemplate (template, Path.Combine (TemplatePath, template.Shortcut + ".template.xml"));
}
}*/
static List<CodeTemplate> LoadTemplates (XmlReader reader)
{
List<CodeTemplate> result = new List<CodeTemplate> ();
try {
while (reader.Read ()) {
if (reader.IsStartElement ()) {
switch (reader.LocalName) {
case Node:
string fileVersion = reader.GetAttribute (VersionAttribute);
if (fileVersion != Version)
return null;
break;
case CodeTemplate.Node:
result.Add (CodeTemplate.Read (reader));
break;
}
}
}
} catch (Exception e) {
LoggingService.LogError ("CodeTemplateService: Exception while loading template.", e);
return null;
} finally {
reader.Close ();
}
return result;
}
int RecurseWorkUnit(AssetType in_type, System.IO.FileInfo in_workUnit, string in_currentPathInProj, string in_currentPhysicalPath, LinkedList <AkWwiseProjectData.PathElement> in_pathAndIcons, string in_parentPhysicalPath = "")
{
m_WwuToProcess.Remove(in_workUnit.FullName);
System.Xml.XmlReader reader = null;
int wwuIndex = -1;
try
{
//Progress bar stuff
string msg = "Parsing Work Unit " + in_workUnit.Name;
EditorUtility.DisplayProgressBar(s_progTitle, msg, (float)m_currentWwuCnt / (float)m_totWwuCnt);
m_currentWwuCnt++;
in_currentPathInProj = System.IO.Path.Combine(in_currentPathInProj, System.IO.Path.GetFileNameWithoutExtension(in_workUnit.Name));
in_pathAndIcons.AddLast(new AkWwiseProjectData.PathElement(System.IO.Path.GetFileNameWithoutExtension(in_workUnit.Name), AkWwiseProjectData.WwiseObjectType.WORKUNIT));
string WwuPhysicalPath = System.IO.Path.Combine(in_currentPhysicalPath, in_workUnit.Name);
AkWwiseProjectData.WorkUnit wwu = null;
ReplaceWwuEntry(WwuPhysicalPath, in_type, out wwu, out wwuIndex);
wwu.ParentPhysicalPath = in_parentPhysicalPath;
wwu.PhysicalPath = WwuPhysicalPath;
wwu.Guid = "";
wwu.SetLastTime(System.IO.File.GetLastWriteTime(in_workUnit.FullName));
reader = System.Xml.XmlReader.Create(in_workUnit.FullName);
reader.MoveToContent();
reader.Read();
while (!reader.EOF && reader.ReadState == System.Xml.ReadState.Interactive)
{
if (reader.NodeType == System.Xml.XmlNodeType.Element && reader.Name.Equals("WorkUnit"))
{
if (wwu.Guid.Equals(""))
{
wwu.Guid = reader.GetAttribute("ID");
}
string persistMode = reader.GetAttribute("PersistMode");
if (persistMode == "Reference")
{
// ReadFrom advances the reader
var matchedElement = System.Xml.Linq.XNode.ReadFrom(reader) as System.Xml.Linq.XElement;
string newWorkUnitPath = System.IO.Path.Combine(in_workUnit.Directory.FullName, matchedElement.Attribute("Name").Value + ".wwu");
var newWorkUnit = new System.IO.FileInfo(newWorkUnitPath);
// Parse the referenced Work Unit
if (m_WwuToProcess.Contains(newWorkUnit.FullName))
{
RecurseWorkUnit(in_type, newWorkUnit, in_currentPathInProj, in_currentPhysicalPath, in_pathAndIcons, WwuPhysicalPath);
}
}
else
{
// If the persist mode is "Standalone" or "Nested", it means the current XML tag
// is the one corresponding to the current file. We can ignore it and advance the reader
reader.Read();
}
}
else if (reader.NodeType == System.Xml.XmlNodeType.Element && reader.Name.Equals("AuxBus"))
{
in_currentPathInProj = System.IO.Path.Combine(in_currentPathInProj, reader.GetAttribute("Name"));
in_pathAndIcons.AddLast(new AkWwiseProjectData.PathElement(reader.GetAttribute("Name"), AkWwiseProjectData.WwiseObjectType.AUXBUS));
bool isEmpty = reader.IsEmptyElement;
AddElementToList(in_currentPathInProj, reader, in_type, in_pathAndIcons, wwuIndex);
if (isEmpty)
{
in_currentPathInProj = in_currentPathInProj.Remove(in_currentPathInProj.LastIndexOf(System.IO.Path.DirectorySeparatorChar));
in_pathAndIcons.RemoveLast();
}
}
// Busses and folders act the same for the Hierarchy: simply add them to the path
else if (reader.NodeType == System.Xml.XmlNodeType.Element && (reader.Name.Equals("Folder") || reader.Name.Equals("Bus")))
{
//check if node has children
if (!reader.IsEmptyElement)
{
// Add the folder/bus to the path
in_currentPathInProj = System.IO.Path.Combine(in_currentPathInProj, reader.GetAttribute("Name"));
if (reader.Name.Equals("Folder"))
{
in_pathAndIcons.AddLast(new AkWwiseProjectData.PathElement(reader.GetAttribute("Name"), AkWwiseProjectData.WwiseObjectType.FOLDER));
}
else if (reader.Name.Equals("Bus"))
{
in_pathAndIcons.AddLast(new AkWwiseProjectData.PathElement(reader.GetAttribute("Name"), AkWwiseProjectData.WwiseObjectType.BUS));
}
}
// Advance the reader
reader.Read();
}
else if (reader.NodeType == System.Xml.XmlNodeType.EndElement && (reader.Name.Equals("Folder") || reader.Name.Equals("Bus") || reader.Name.Equals("AuxBus")))
{
// Remove the folder/bus from the path
in_currentPathInProj = in_currentPathInProj.Remove(in_currentPathInProj.LastIndexOf(System.IO.Path.DirectorySeparatorChar));
in_pathAndIcons.RemoveLast();
// Advance the reader
reader.Read();
}
else if (reader.NodeType == System.Xml.XmlNodeType.Element && reader.Name.Equals(in_type.XmlElementName))
{
// Add the element to the list
AddElementToList(in_currentPathInProj, reader, in_type, in_pathAndIcons, wwuIndex);
}
else
{
reader.Read();
}
}
// Sort the newly populated Wwu alphabetically
SortWwu(in_type.RootDirectoryName, wwuIndex);
}
catch (System.Exception e)
{
Debug.LogError(e.ToString());
wwuIndex = -1;
}
if (reader != null)
{
reader.Close();
}
in_pathAndIcons.RemoveLast();
return(wwuIndex);
}
public bool ProcessMessage(MessagePackage message)
{
try
{
string xmlString = message.GetMessageXml();
string schemaFile = _param.GetFullPath(_config.SchemaFileName);
try
{
_param.Log.Write(LogType.Debug, "Start Validate Meta File");
XmlReaderSettings rs = new XmlReaderSettings();
try
{
rs.ValidationType = ValidationType.Schema;
rs.Schemas.Add(null, schemaFile);
rs.ValidationEventHandler += new System.Xml.Schema.ValidationEventHandler(RS_ValidationEventHandler);
}
catch (Exception ex)
{
_param.Log.Write(LogType.Debug, "Load schema file error" + ex.Message);
_isValid = false;
return(false);
}
finally
{
}
System.Xml.XmlReader xr = XmlReader.Create(new StringReader(xmlString), rs);
try
{
while (xr.Read() && _isValid)
{
_param.Log.Write(LogType.Debug, "Read XML Information: " + xr.Value);
}
}
catch (Exception ex)
{
_param.Log.Write(LogType.Error, "System gets error while reading XML, " + ex.Message);
_isValid = false;
}
finally
{
xr.Close();
}
}
catch (Exception ex)
{
_param.Log.Write(LogType.Error, "System gets error while validateing XML, " + ex.Message);
_isValid = false;
}
finally
{
}
return(_isValid);
}
catch (Exception e)
{
WriteLog(e);
return(false);
}
}
public override void Close()
{
CheckAsync();
_coreReader.Close();
}
private void BriefAction(XmlReader reader, ServiceAction action)
{
reader.Read ();
foreach (Argument argument in action.Arguments.Values) {
argument.Value = argument.RelatedStateVariable.DefaultValue;
}
while (Helper.ReadToNextElement (reader)) {
if (!action.Arguments.ContainsKey (reader.Name)) {
throw UpnpControlException.InvalidArgs ();
}
Argument argument = action.Arguments[reader.Name];
if (argument.RelatedStateVariable.DataType.IsEnum) {
try {
argument.Value = Enum.Parse (argument.RelatedStateVariable.DataType, reader.ReadString ());
} catch {
throw UpnpControlException.ArgumentValueOutOfRange ();
}
} else {
try {
argument.Value = Convert.ChangeType (reader.ReadString (), argument.RelatedStateVariable.DataType);
} catch {
throw UpnpControlException.InvalidArgs ();
}
// TODO handle min, max, and step
}
}
reader.Close ();
}
// Closes the input stream ot TextReader, changes the ReadState to Closed and sets all properties to zero/string.Empty
public override void Close()
{
_coreReader.Close();
_parsingFunction = ParsingFunction.ReaderClosed;
}
/// <summary>
/// Parses a highlighting definition.
/// </summary>
/// <param name="highlighter">The highlighting strategy, which is set.</param>
/// <param name="syntaxMode">The syntax highlighting mode.</param>
/// <param name="xmlReader">The XML reader.</param>
/// <returns></returns>
private static DefaultHighlightingStrategy Parse(DefaultHighlightingStrategy highlighter, SyntaxMode syntaxMode, XmlReader xmlReader)
{
if (syntaxMode == null)
throw new ArgumentNullException("syntaxMode");
if (xmlReader == null)
throw new ArgumentNullException("xmlReader");
try
{
List<ValidationEventArgs> errors = null;
XmlReaderSettings settings = new XmlReaderSettings();
Stream shemaStream = typeof(HighlightingDefinitionParser).Assembly.GetManifestResourceStream("DigitalRune.Windows.TextEditor.Resources.Mode.xsd");
settings.Schemas.Add("", new XmlTextReader(shemaStream));
settings.Schemas.ValidationEventHandler += delegate(object sender, ValidationEventArgs args)
{
if (errors == null)
{
errors = new List<ValidationEventArgs>();
}
errors.Add(args);
};
settings.ValidationType = ValidationType.Schema;
XmlReader validatingReader = XmlReader.Create(xmlReader, settings);
XmlDocument doc = new XmlDocument();
doc.Load(validatingReader);
if (highlighter == null)
highlighter = new DefaultHighlightingStrategy(doc.DocumentElement.Attributes["name"].InnerText);
if (doc.DocumentElement.HasAttribute("extends"))
{
KeyValuePair<SyntaxMode, ISyntaxModeFileProvider> entry = HighlightingManager.Manager.FindHighlighterEntry(doc.DocumentElement.GetAttribute("extends"));
if (entry.Key == null)
{
throw new HighlightingDefinitionInvalidException("Cannot find referenced highlighting source " + doc.DocumentElement.GetAttribute("extends"));
}
else
{
highlighter = Parse(highlighter, entry.Key, entry.Value.GetSyntaxModeFile(entry.Key));
if (highlighter == null) return null;
}
}
if (doc.DocumentElement.HasAttribute("extensions"))
{
highlighter.Extensions = doc.DocumentElement.GetAttribute("extensions").Split(new char[] { ';', '|' });
}
XmlElement environment = doc.DocumentElement["Environment"];
if (environment != null)
{
foreach (XmlNode node in environment.ChildNodes)
{
if (node is XmlElement)
{
XmlElement el = (XmlElement) node;
if (el.Name == "Custom")
highlighter.SetColorFor(el.GetAttribute("name"), el.HasAttribute("bgcolor") ? new HighlightBackground(el) : new HighlightColor(el));
else
highlighter.SetColorFor(el.Name, el.HasAttribute("bgcolor") ? new HighlightBackground(el) : new HighlightColor(el));
}
}
}
// parse properties
if (doc.DocumentElement["Properties"] != null)
foreach (XmlElement propertyElement in doc.DocumentElement["Properties"].ChildNodes)
highlighter.Properties[propertyElement.Attributes["name"].InnerText] = propertyElement.Attributes["value"].InnerText;
if (doc.DocumentElement["Digits"] != null)
highlighter.DigitColor = new HighlightColor(doc.DocumentElement["Digits"]);
XmlNodeList nodes = doc.DocumentElement.GetElementsByTagName("RuleSet");
foreach (XmlElement element in nodes)
highlighter.AddRuleSet(new HighlightRuleSet(element));
xmlReader.Close();
if (errors != null)
{
StringBuilder msg = new StringBuilder();
foreach (ValidationEventArgs args in errors)
{
msg.AppendLine(args.Message);
}
throw new HighlightingDefinitionInvalidException(msg.ToString());
}
else
{
return highlighter;
}
}
catch (Exception e)
{
throw new HighlightingDefinitionInvalidException("Could not load mode definition file '" + syntaxMode.FileName + "'.\n", e);
}
}
public override void Close()
{
reader.Close();
}
