public static void WriteXmlDoc(this ITextOutput output, string text)
{
foreach (var kv in SimpleXmlParser.Parse(text))
{
output.Write(kv.Key, kv.Value);
}
}
/// <summary>
/// Import the names from XML.
/// @throws IOException on error
/// </summary>
/// <param name="inp">the XML source. The reader is not closed</param>
/// <returns>the names</returns>
public static Hashtable ImportFromXml(TextReader inp)
{
SimpleNamedDestination names = new SimpleNamedDestination();
SimpleXmlParser.Parse(names, inp);
return(names._xmlNames);
}
/// <summary>
/// Reads initial file and imports data
/// </summary>
/// <returns></returns>
public override List <T> ImportFile()
{
if (string.IsNullOrEmpty(this.DownloadedFilename))
{
throw new FileNotFoundException("There is no any file downloaded. Call DownloadXmlFile first.");
}
List <T> products = new List <T>(100);
try
{
SimpleXmlParser parser = new SimpleXmlParser(new System.IO.FileInfo(this.DownloadedFilename));
List <Dictionary <string, string> > parsed = parser.Parse();
//Go throw rows and validate each row
foreach (Dictionary <string, string> dr in parsed)
{
T instance = this.ParseRow(dr);
if (instance == null)
{
continue;
}
products.Add(instance);
}
}
catch (Exception ex)
{
throw new Exception(ex.Message, ex);
}
return(products);
}
/// <summary>
/// Import the bookmarks from XML.
/// @throws IOException on error
/// </summary>
/// <param name="inp">the XML source. The stream is not closed</param>
/// <returns>the bookmarks</returns>
public static ArrayList ImportFromXml(Stream inp)
{
SimpleBookmark book = new SimpleBookmark();
SimpleXmlParser.Parse(book, inp);
return(book._topList);
}
/// <summary>
/// Import the bookmarks from XML.
/// @throws IOException on error
/// </summary>
/// <param name="inp">the XML source. The reader is not closed</param>
/// <returns>the bookmarks</returns>
public static ArrayList ImportFromXml(TextReader inp)
{
var book = new SimpleBookmark();
SimpleXmlParser.Parse(book, inp);
return(book._topList);
}
/// <summary>
/// Import the names from XML.
/// @throws IOException on error
/// </summary>
/// <param name="inp">the XML source. The stream is not closed</param>
/// <returns>the names</returns>
public static Hashtable ImportFromXml(Stream inp)
{
var names = new SimpleNamedDestination();
SimpleXmlParser.Parse(names, inp);
return(names._xmlNames);
}
/// <summary>
/// Exports the bookmarks to XML. Only of use if the generation is to be include in
/// some other XML document.
/// whatever the encoding
/// @throws IOException on error
/// </summary>
/// <param name="list">the bookmarks</param>
/// <param name="outp">the export destination. The writer is not closed</param>
/// <param name="indent">the indentation level. Pretty printing significant only</param>
/// <param name="onlyAscii">codes above 127 will always be escaped with &#nn; if true ,</param>
public static void ExportToXmlNode(ArrayList list, TextWriter outp, int indent, bool onlyAscii)
{
var dep = "";
for (var k = 0; k < indent; ++k)
{
dep += " ";
}
foreach (Hashtable map in list)
{
string title = null;
outp.Write(dep);
outp.Write("<Title ");
ArrayList kids = null;
foreach (DictionaryEntry entry in map)
{
var key = (string)entry.Key;
if (key.Equals("Title"))
{
title = (string)entry.Value;
continue;
}
else if (key.Equals("Kids"))
{
kids = (ArrayList)entry.Value;
continue;
}
else
{
outp.Write(key);
outp.Write("=\"");
var value = (string)entry.Value;
if (key.Equals("Named") || key.Equals("NamedN"))
{
value = EscapeBinaryString(value);
}
outp.Write(SimpleXmlParser.EscapeXml(value, onlyAscii));
outp.Write("\" ");
}
}
outp.Write(">");
if (title == null)
{
title = "";
}
outp.Write(SimpleXmlParser.EscapeXml(title, onlyAscii));
if (kids != null)
{
outp.Write("\n");
ExportToXmlNode(kids, outp, indent + 1, onlyAscii);
outp.Write(dep);
}
outp.Write("</Title>\n");
}
}
/// <summary>
/// Exports the bookmarks to XML.
/// whatever the encoding
/// @throws IOException on error
/// </summary>
/// <param name="list">the bookmarks</param>
/// <param name="wrt">the export destination. The writer is not closed</param>
/// <param name="encoding">the encoding according to IANA conventions</param>
/// <param name="onlyAscii">codes above 127 will always be escaped with &#nn; if true ,</param>
public static void ExportToXml(ArrayList list, TextWriter wrt, string encoding, bool onlyAscii)
{
wrt.Write("<?xml version=\"1.0\" encoding=\"");
wrt.Write(SimpleXmlParser.EscapeXml(encoding, onlyAscii));
wrt.Write("\"?>\n<Bookmark>\n");
ExportToXmlNode(list, wrt, 1, onlyAscii);
wrt.Write("</Bookmark>\n");
wrt.Flush();
}
public void TestDuplicateAttribute()
{
XmlParser parser = new SimpleXmlParser();
//TextReader t = new StringReader("<xml></xml>");
var doc = XDocument.Load(@"<xml att=""123"" att=""1234""></xml>");
parser.Document = doc;
parser.ParseDocument(LoggerType.DEBUG);
}
public void SimpleXMLDocument()
{
XmlParser parser = new SimpleXmlParser();
//TextReader t = new StringReader("<xml></xml>");
var doc = XDocument.Load("<xml></xml>");
parser.Document = doc;
parser.ParseDocument(LoggerType.DEBUG);
}
public void TryReadingXmlFile()
{
ReadXml r = new ReadXml();
r.StringPath = @"C:\Users\dor\source\repos\xmlTest\XmlParser\test.xml";
XmlParser parser = new SimpleXmlParser();
parser.Document = r.ReadFile();
}
public void CheckErrorLogger()
{
MetronikParser.Parser.XmlParser parser = new SimpleXmlParser();
var doc = new XmlDocument();
doc.LoadXml("<xml></xml>");
using (parser.Log = LoggerFactory.GetLogger(LoggerType.DEBUG))
{
parser.Log.LogError("Testing Logger");
}
}
public void Parse(Stream stream, IPatternConsumer consumer)
{
Consumer = consumer;
try
{
SimpleXmlParser.Parse(this, stream);
}
finally
{
try { stream.Dispose(); } catch { }
}
}
private XmlParser LoadParser()
{
XmlParser parser = new SimpleXmlParser();
parser.Document = XDocument.Parse(
@"<root>
<ime testAtt=""testAtt"">Rok</ime>
<priimek>Dolinar</priimek>
<kraj>Javorje 34</kraj>
<sola>
<ime_sole>FRI</ime_sole>
<lokacija>Vecna pot</lokacija>
</sola>
</root>");
return(parser);
}
/// <summary>
/// Exports the bookmarks to XML.
/// whatever the encoding
/// @throws IOException on error
/// </summary>
/// <param name="names">the names</param>
/// <param name="wrt">the export destination. The writer is not closed</param>
/// <param name="encoding">the encoding according to IANA conventions</param>
/// <param name="onlyAscii">codes above 127 will always be escaped with &#nn; if true ,</param>
public static void ExportToXml(Hashtable names, TextWriter wrt, string encoding, bool onlyAscii)
{
wrt.Write("<?xml version=\"1.0\" encoding=\"");
wrt.Write(SimpleXmlParser.EscapeXml(encoding, onlyAscii));
wrt.Write("\"?>\n<Destination>\n");
foreach (string key in names.Keys)
{
string value = (string)names[key];
wrt.Write(" <Name Page=\"");
wrt.Write(SimpleXmlParser.EscapeXml(value, onlyAscii));
wrt.Write("\">");
wrt.Write(SimpleXmlParser.EscapeXml(EscapeBinaryString(key), onlyAscii));
wrt.Write("</Name>\n");
}
wrt.Write("</Destination>\n");
wrt.Flush();
}
/// <summary>
/// Reads an XFDF form.
/// @throws IOException on error
/// </summary>
/// <param name="filename">the file name of the form</param>
public XfdfReader(string filename)
{
FileStream fin = null;
try
{
fin = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.Read);
SimpleXmlParser.Parse(this, fin);
}
finally
{
try
{
fin?.Dispose();
} catch { }
}
}
public void CheckForNullDocument()
{
MetronikParser.Parser.XmlParser parser = new SimpleXmlParser();
parser.Document = null;
parser.ParseDocument(LoggerType.DEBUG);
}
public void Parse(TextReader reader)
{
SimpleXmlParser.Parse(this, null, reader, true);
}
/// <summary>
/// Reads an XFDF form.
/// @throws IOException on error
/// </summary>
/// <param name="xfdfIn">the byte array with the form</param>
public XfdfReader(byte[] xfdfIn)
{
SimpleXmlParser.Parse(this, new MemoryStream(xfdfIn));
}
