public void ReadXml(XmlReader reader)
{
var elementName = string.Empty;
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element)
{
elementName = reader.Name;
switch (elementName)
{
case "TypeAliases":
{
var subReader = reader.ReadSubtree();
var aliases = new List<NetTypeAlias>();
while (subReader.ReadToFollowing("TypeAlias"))
{
var aliasReader = subReader.ReadSubtree();
var typeAlias = new NetTypeAlias();
typeAlias.ReadXml(aliasReader);
aliases.Add(typeAlias);
}
TypeAliases = aliases.ToArray();
break;
}
case "Snippets":
{
var subReader = reader.ReadSubtree();
var snippets = new List<Snippet>();
while (subReader.ReadToFollowing("Snippet"))
{
var snippet = new Snippet();
snippet.ReadXml(subReader);
snippets.Add(snippet);
}
Snippets = snippets.ToArray();
break;
}
}
}
else if (reader.NodeType == XmlNodeType.Text)
{
switch (elementName)
{
case "Modifiers":
Modifiers = reader.Value.Split(' ');
break;
case "MemberIdentifiers":
MemberIdentifiers = reader.Value.Split(' ');
break;
case "Keywords":
Keywords = reader.Value.Split(' ');
break;
}
}
else if (reader.NodeType == XmlNodeType.EndElement)
{
elementName = string.Empty;
}
}
}
public static ServiceResponse Deserialize(XmlReader reader, ServiceResponse serviceResponse)
{
if (reader.IsStartElement(DTD.Response.TagServiceResponse))
{
if (serviceResponse == null)
{
serviceResponse = new ServiceResponse();
}
if (!reader.IsEmptyElement)
{
reader.ReadStartElement();
do
{
#region <ERROR>
if (reader.IsStartElement(DTD.Response.ServiceResponse.TagError))
{
if(int.Parse(reader.GetAttribute(DTD.Error.TagNumber))!=0)
{
throw XMLErrorSerializer.Deserialize(reader.ReadSubtree());
}
else
{
reader.Skip();
}
}
#endregion <ERROR>
#region <OID>
if (reader.IsStartElement(DTD.TagOID))
{
serviceResponse.Oid = XMLAdaptorOIDSerializer.Deserialize(reader.ReadSubtree());
}
#endregion <OID>
#region <Arguments>
if (reader.IsStartElement(DTD.Response.ServiceResponse.TagArguments))
{
serviceResponse.Arguments = XMLArgumentsSerializer.Deserialize(reader.ReadSubtree());
}
#endregion <Arguments>
} while (reader.Read());
}
else
{
reader.Skip();
}
}
else
{
throw new ArgumentException("Xml Reader don't have the Service.Response in Start Element.", "XmlReader reader");
}
return serviceResponse;
}
public void ReadFrom(System.Xml.XmlReader x)
{
XmlReader s = null;
while (x.Read())
{
switch (x.LocalName)
{
case "BinaryPath":
BinPath = x.ReadString();
break;
case "TargetConfiguration":
s = x.ReadSubtree();
var t = new LinkTargetConfiguration();
t.LoadFrom(s);
LinkTargetConfigurations [t.TargetType] = t;
s.Close();
break;
case "DefaultLibs":
s = x.ReadSubtree();
while (s.Read())
{
if (s.LocalName == "lib")
{
DefaultLibraries.Add(s.ReadString());
}
}
s.Close();
break;
case "Includes":
s = x.ReadSubtree();
var paths = new List <string> ();
while (s.Read())
{
if (s.LocalName == "Path")
{
ParseCache.ParsedDirectories.Add(s.ReadString());
}
}
s.Close();
break;
}
}
}
/// <summary> Reads the dmdSec at the current position in the XmlTextReader and associates it with the
/// entire package </summary>
/// <param name="Input_XmlReader"> Open XmlReader from which to read the metadata </param>
/// <param name="Return_Package"> Package into which to read the metadata</param>
/// <param name="Options"> Dictionary of any options which this METS section reader may utilize</param>
/// <returns> TRUE if successful, otherwise FALSE</returns>
public bool Read_dmdSec(XmlReader Input_XmlReader, SobekCM_Item Return_Package, Dictionary<string, object> Options)
{
// Ensure this metadata module extension exists
LearningObjectMetadata lomInfo = Return_Package.Get_Metadata_Module(GlobalVar.IEEE_LOM_METADATA_MODULE_KEY) as LearningObjectMetadata;
if (lomInfo == null)
{
lomInfo = new LearningObjectMetadata();
Return_Package.Add_Metadata_Module(GlobalVar.IEEE_LOM_METADATA_MODULE_KEY, lomInfo);
}
// Loop through reading each XML node
do
{
// If this is the end of this section, return
if ((Input_XmlReader.NodeType == XmlNodeType.EndElement) && ((Input_XmlReader.Name == "METS:mdWrap") || (Input_XmlReader.Name == "mdWrap")))
return true;
// get the right division information based on node type
if (Input_XmlReader.NodeType == XmlNodeType.Element)
{
string name = Input_XmlReader.Name.ToLower();
if (( lom_namespace.Length > 0 ) && ( name.IndexOf( lom_namespace ) == 0))
name = name.Substring(lom_namespace.Length);
switch (name)
{
case "general":
read_general(Input_XmlReader.ReadSubtree(), lomInfo);
break;
case "lifecycle":
read_lifecycle(Input_XmlReader.ReadSubtree(), lomInfo);
break;
case "technical":
read_technical(Input_XmlReader.ReadSubtree(), lomInfo);
break;
case "educational":
read_educational(Input_XmlReader.ReadSubtree(), lomInfo);
break;
case "classification":
read_classification(Input_XmlReader.ReadSubtree(), lomInfo);
break;
}
}
} while (Input_XmlReader.Read());
return true;
}
/// <summary>
/// Deserializes an ChangedItem from an XML file.
/// </summary>
/// <param name="reader">XMLReader where the ChangedItem is.</param>
/// <returns>ChangedItem.</returns>
public static ChangedItem Deserialize(XmlReader reader)
{
ChangedItem lResult = null;
if (reader.IsStartElement(DTD.Error.ChangedItems.TagChangedItem))
{
lResult = new ChangedItem();
string stringModelType = reader.GetAttribute(DTD.Error.ChangedItems.ChangedItem.TagType);
ModelType modelType = Convert.StringTypeToMODELType(stringModelType);
if (modelType == ModelType.Oid)
{
lResult.Type = Convert.MODELTypeToStringType(ModelType.Oid);
lResult.ClassName = stringModelType;
}
else
{
lResult.Type = stringModelType;
lResult.ClassName = string.Empty;
}
lResult.Name = reader.GetAttribute(DTD.Error.ChangedItems.ChangedItem.TagName);
if (!reader.IsEmptyElement)
{
reader.ReadStartElement();
if (reader.IsStartElement(DTD.Error.ChangedItems.ChangedItem.TagChangedItemOldValue))
{
lResult.OldValue = XMLChangedItemValueSerializer.Deserialize(reader.ReadSubtree(),lResult.Type, lResult.ClassName);
reader.ReadEndElement();
}
if (reader.IsStartElement(DTD.Error.ChangedItems.ChangedItem.TagChangedItemNewValue))
{
lResult.NewValue = XMLChangedItemValueSerializer.Deserialize(reader.ReadSubtree(), lResult.Type, lResult.ClassName);
reader.ReadEndElement();
}
}
else
{
reader.Skip();
}
}
else
{
throw new ArgumentException("Xml Reader don't have the ChangedItem in Start Element.", "XmlReader reader");
}
return lResult;
}
public bool LoadFrom(DCompilerConfiguration cmpCfg, System.Xml.XmlReader x)
{
if (x.ReadState == ReadState.Initial)
{
x.Read();
}
if (x.MoveToAttribute("Target") &&
!Enum.TryParse(x.ReadContentAsString(), true, out TargetType))
{
return(false);
}
while (x.Read())
{
switch (x.LocalName)
{
// For backward compatibility keep on parsing this
case "CompilerCommand":
cmpCfg.SourceCompilerCommand = x.ReadString();
break;
case "LinkerCommand":
Linker = x.ReadString();
break;
case "Patterns": // ditto
var s = x.ReadSubtree();
cmpCfg.ArgumentPatterns.ReadFrom(s);
s.Close();
break;
case "DebugArgs":
s = x.ReadSubtree();
DebugArguments.ReadFrom(cmpCfg, s);
s.Close();
break;
case "ReleaseArgs":
s = x.ReadSubtree();
ReleaseArguments.ReadFrom(cmpCfg, s);
s.Close();
break;
}
}
return(true);
}
public void ReadFrom(System.Xml.XmlReader x)
{
XmlReader s = null;
while (x.Read())
{
switch (x.LocalName)
{
case "TargetConfiguration":
s = x.ReadSubtree();
var t = new LinkTargetConfiguration();
t.LoadFrom(s);
LinkTargetConfigurations.Add(t);
s.Close();
break;
case "DefaultLibs":
s = x.ReadSubtree();
while (s.Read())
{
if (s.LocalName == "lib")
{
DefaultLibraries.Add(s.ReadString());
}
}
s.Close();
break;
case "Includes":
s = x.ReadSubtree();
while (s.Read())
{
if (s.LocalName == "Path")
{
GlobalParseCache.Add(s.ReadString());
}
}
s.Close();
break;
}
}
}
/// <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);
}
public void ReadXml(System.Xml.XmlReader reader)
{
if (reader.MoveToAttribute("Disabled"))
{
Disabled = reader.Value == "1";
}
reader.ReadStartElement("RuleList");
while (reader.IsStartElement())
{
IXmlSerializable r = null;
switch (reader.Name)
{
case "RegExpRule":
r = new RegExpRule();
break;
case "HostRule":
r = new HostRule();
break;
case "PathRule":
r = new PathRule();
break;
}
if (r != null)
{
r.ReadXml(reader.ReadSubtree());
this.Add((IRule)r);
}
reader.ReadEndElement();
}
}
public void ReadXml(System.Xml.XmlReader reader)
{
if (reader == null)
{
throw new ArgumentNullException("reader");
}
if (reader.LocalName == "TagValueCollection")
{
XmlReader subReader = reader.ReadSubtree();
XPathDocument doc = new XPathDocument(subReader);
var nav = doc.CreateNavigator();
XPathNavigator iter = nav.SelectSingleNode("/TagValueCollection/@Version");
if (iter == null)
{
throw new XmlSchemaException("TagValueCollection does not have a version element");
}
long ver = iter.ValueAsLong;
if (ver == Version)
{
ReadCurrentVersion(nav);
}
else
{
throw new InvalidOperationException();
}
}
}
public void ReadXml(System.Xml.XmlReader reader)
{
reader.MoveToElement();
reader.ReadStartElement();
Type instanceType = base.GetType().BaseType;
while (reader.IsStartElement())
{
if (reader.HasAttributes)
{
XmlNodeType nodeType = reader.NodeType;
Type t = typeof(FileProcessingJournalEntryData <>);
t = t.MakeGenericType(Type.GetType(reader.GetAttribute("type")));
string name = reader.GetAttribute("name");
var ser = XmlSerializerCache.GetOrAdd(t, name);
object obj = ser.Deserialize(reader.ReadSubtree());
reader.ReadEndElement();
this.EntryData.Add((FileProcessingJournalEntryDataBase)obj);
}
else
{
PropertyInfo Prop = instanceType.GetProperty(reader.Name);
if (Prop != null)
{
var h = reader.ReadElementContentAsObject(Prop.Name, "");
Prop.SetValue(this, Convert.ChangeType(h, Prop.PropertyType), null);
}
}
}
}
/// <summary>
/// Generate object from its XML representation</summary>
/// <param name="reader">XmlReader stream from which object is deserialized</param>
public void ReadXml(System.Xml.XmlReader reader)
{
if (reader.ReadToFollowing(this.GetType().Name))
{
reader.ReadStartElement(this.GetType().Name);
if (reader.LocalName == typeof(TabLayout).Name || reader.LocalName == "MultiContent") // MultiContent is old name and is used here for compatibility with old saved layouts
{
DockedContent = new TabLayout(Root, reader.ReadSubtree());
if (DockedContent.Children.Count > 0)
{
ContentSettings contentSettings = DockedContent.Children[0].Settings;
Left = contentSettings.Location.X;
Top = contentSettings.Location.Y;
Width = contentSettings.Size.Width;
Height = contentSettings.Size.Height;
Width = Math.Max(Width, SystemParameters.MinimumWindowWidth);
Height = Math.Max(Height, SystemParameters.MinimumWindowHeight);
Left = Math.Max(SystemParameters.VirtualScreenLeft,
Math.Min(Left, SystemParameters.VirtualScreenWidth + SystemParameters.VirtualScreenLeft - Width));
Top = Math.Max(SystemParameters.VirtualScreenTop,
Math.Min(Top, SystemParameters.VirtualScreenHeight + SystemParameters.VirtualScreenTop - Height));
reader.ReadEndElement();
}
}
reader.ReadEndElement();
}
}
public static ServiceRequest Deserialize(XmlReader reader, ServiceRequest serviceRequest)
{
if (reader.IsStartElement(DTD.Request.TagServiceRequest))
{
if (serviceRequest == null)
{
serviceRequest = new ServiceRequest();
}
serviceRequest.Class = reader.GetAttribute(DTD.Request.ServiceRequest.TagClass);
serviceRequest.Name = reader.GetAttribute(DTD.Request.ServiceRequest.TagService);
if (!reader.IsEmptyElement)
{
reader.ReadStartElement();
serviceRequest.Arguments = XMLArgumentsSerializer.Deserialize(reader.ReadSubtree());
}
else
{
reader.Skip();
}
}
else
{
throw new ArgumentException("Xml Reader don't have the Service.Request in Start Element.", "XmlReader reader");
}
return serviceRequest;
}
public virtual void ReadXml(System.Xml.XmlReader topReader)
{
this.m_isBeingRead = true;
string infoName = topReader.Name;
XmlReader reader = topReader.ReadSubtree();
XPathDocument doc = new XPathDocument(reader);
var nav = doc.CreateNavigator();
XPathNavigator iter = nav.SelectSingleNode(String.Format("/{0}/Version", infoName));
if (iter == null)
{
throw new XmlException("ExperimentInfo is missing version information.");
}
else
{
long ver = iter.ValueAsLong;
if (ver == CurrentVersion)
{
ReadCurrentVersion(nav, infoName);
}
else if (ver == 1)
{
ReadVersion1(nav, infoName);
}
else
{
throw new InvalidOperationException("ExperimentInfo has an invalid version number");
}
}
this.m_isBeingRead = false;
}
/// <summary>
/// return a TreeNode that is the root of a tree representing this Element node with descendants
/// </summary>
/// <param name="xmlDoc"></param>
/// <returns></returns>
private TreeNode getTreeRootedAtElementNode(XmlReader xmlDoc)
{
TreeNode MainTreeRoot = getSingleNode(xmlDoc);
TreeNode Attributes = new TreeNode();
Attributes.Text = "<Attributes>";
while (xmlDoc.MoveToNextAttribute())
{
Attributes.Nodes.Add(getSingleNode(xmlDoc));
}
MainTreeRoot.Nodes.Add(Attributes);
xmlDoc.Read();
while(!xmlDoc.EOF)
{
if(xmlDoc.NodeType == XmlNodeType.Element)
{
using (XmlReader childElement = xmlDoc.ReadSubtree())
{
childElement.Read();
MainTreeRoot.Nodes.Add(getTreeRootedAtElementNode(childElement));
}
}
else if(xmlDoc.NodeType == XmlNodeType.EndElement)
{
return MainTreeRoot;
}
else
{
MainTreeRoot.Nodes.Add(getSingleNode(xmlDoc));
}
xmlDoc.Read();
}
return MainTreeRoot;
}
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();
}
public override void ReadXml(XmlReader reader)
{
Keyword.Clear();
var subReader = reader.ReadSubtree();
if (CheckEmptyNode(subReader, "KeywordList", string.Empty, true))
return;
while (!subReader.EOF)
{
subReader.MoveToContent();
if (subReader.LocalName == "Keyword")
{
var att = subReader.GetAttribute("vocabulary");
reader.ReadStartElement("Keyword");
var val = reader.ReadContentAsString();
reader.ReadEndElement();
Keyword.Add(new Keyword { Vocabulary = att, Value = val });
}
else
{
subReader.ReadEndElement();
}
}
reader.Skip();
}
//=====================================================================
/// <summary>
/// Constructor
/// </summary>
/// <param name="configuration">The XML reader from which to get the configuration</param>
public TypeFilter(XmlReader configuration)
{
if(configuration.NodeType != XmlNodeType.Element || configuration.Name != "type")
throw new InvalidOperationException("The configuration element must be named 'type'");
memberFilters = new List<MemberFilter>();
name = configuration.GetAttribute("name");
exposed = Convert.ToBoolean(configuration.GetAttribute("expose"), CultureInfo.InvariantCulture);
// If not exposed, check for a required attribute which forces it to be exposed. This allows a
// way to expose it and indicate that it should always be exposed in the configuration file.
if(!exposed)
{
required = Convert.ToBoolean(configuration.GetAttribute("required"), CultureInfo.InvariantCulture);
if(required)
exposed = true;
}
XmlReader subtree = configuration.ReadSubtree();
while(subtree.Read())
if(subtree.NodeType == XmlNodeType.Element && subtree.Name == "member")
memberFilters.Add(new MemberFilter(subtree));
subtree.Close();
}
public static void ProcessLinks(XmlReader reader, NpgsqlConnection connection)
{
var page_title = reader.GetAttribute("title");
List<string> titles;
XmlReader inner;
inner = reader.ReadSubtree();
titles = new List<string>();
while (inner.ReadToFollowing("link")) titles.Add(inner.ReadElementContentAsString());
if (titles.Count() == 0) return;
// Now we have a list of titles construct a subquery to get the ID's
// I could use this query, which looks nicer, but EXPLAIN says it costs a little bit more.
// SELECT id FROM pages WHERE title IN ('Apple','ElementalAllotropes')
// AND redirect IS NULL UNION SELECT p2.id FROM pages AS p1
// JOIN pages AS p2 ON p1.title IN ('Apple','ElementalAllotropes') AND p2.title = p1.redirect AND p2.redirect IS NULL;
var select_command_text = string.Format(PostgresSchema.LINK_ID_QUERY,
string.Join(",", (from val in Enumerable.Range(0, titles.Count)
select string.Format(":title_{0}", val))));
// Update our links to be the array of ID's using the subquery above
var command = new NpgsqlCommand(string.Format("UPDATE pages SET links = ARRAY({0}) WHERE title = :title", select_command_text), connection);
foreach (var val in Enumerable.Range(0, titles.Count)) command.Parameters.AddWithValue("title_"+val, titles[val]);
command.Parameters.Add(new NpgsqlParameter("title", page_title));
command.ExecuteNonQuery();
}
public override void ReadXml(XmlReader reader)
{
if (CheckEmptyNode(reader, "DCPType", Namespace))
return;
reader.MoveToContent();
Http.ReadXml(reader.ReadSubtree());
}
public void ReadXml(XmlReader reader)
{
if (reader.LocalName != "Envelope" && !reader.ReadToDescendant("Envelope", SoapEnvelopeNamespace))
throw new InvalidDataException();
XmlHelper.ParseXml(reader, new XmlParseSet
{
{"Header", () => XmlHelper.ParseXmlDictionary(reader.ReadSubtree(), this.Headers)},
{"Body", () => XmlHelper.ParseXml(reader.ReadSubtree(), new XmlParseSet {
() => {
this.Namespace = reader.NamespaceURI;
this.Method = reader.LocalName;
XmlHelper.ParseXmlDictionary(reader, this.Arguments);
}})}
});
}
public bool ParseLogs()
{
try
{
foreach (string f in _root.Files)
{
_reader = new XmlTextReader(f);
Console.WriteLine("Loading Log");
while (_reader.Read())
{
if (_reader.Name == "State")
{
Dictionary<String, String> attributes = GetAttributes();
_root.States.Add(new Model.PMState(attributes));
ParseState(_reader.ReadSubtree());
}
}
}
}
catch
{
return false;
}
return true;
}
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>
/// Generates an object from its XML representation.
/// </summary>
/// <param name="reader">The <see cref="T:System.Xml.XmlReader"/> stream from which the object is deserialized.</param>
public override void ReadXml(XmlReader reader)
{
if (reader == null)
throw new ArgumentNullException("reader");
if (reader.LocalName == "DirectoryPath")
{
XmlReader subReader = reader.ReadSubtree();
XPathDocument doc = new XPathDocument(subReader);
var nav = doc.CreateNavigator();
XPathNavigator iter = nav.SelectSingleNode("/DirectoryPath/Version");
if (iter != null)
{
long ver = iter.ValueAsLong;
if (ver == CurrentVersion)
{
ReadCurrentVersion(nav);
}
else
{
throw new NotSupportedException("Version not supported.");
}
}
else
{
throw new NotSupportedException("Could not read version of DirectoryPath. ");
}
}
}
public void LoadFrom(System.Xml.XmlReader x)
{
if (x.ReadState == ReadState.Initial)
{
x.Read();
}
if (x.MoveToAttribute("Target"))
{
TargetType = (DCompileTarget)Enum.Parse(typeof(DCompileTarget), x.ReadContentAsString());
}
while (x.Read())
{
switch (x.LocalName)
{
case "CompilerCommand":
Compiler = x.ReadString();
break;
case "LinkerCommand":
Linker = x.ReadString();
break;
case "ObjectLinkPattern":
ObjectFileLinkPattern = x.ReadString();
break;
case "IncludePathPattern":
IncludePathPattern = x.ReadString();
break;
case "DebugArgs":
var s = x.ReadSubtree();
DebugArguments.ReadFrom(s);
s.Close();
break;
case "ReleaseArgs":
var s2 = x.ReadSubtree();
ReleaseArguments.ReadFrom(s2);
s2.Close();
break;
}
}
}
/// <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);
}
public override void ReadXml(XmlReader reader)
{
reader.MoveToContent();
XmlReader xr = reader.ReadSubtree();
xr.MoveToContent();
if (xr.Value != "")
_replyMessage = xr.Value;
base.ReadXml(xr);
}
/// <summary>
/// Reads a list of maze genomes from an XML file.
/// </summary>
/// <param name="xr">Reference to the XmlReader.</param>
/// <param name="genomeFactory">A MazeGenomeFactory to construct genomes against.</param>
/// <returns>Instantiated list of maze genomes.</returns>
public static List<MazeGenome> ReadCompleteGenomeList(XmlReader xr, MazeGenomeFactory genomeFactory)
{
// Find <Root>
XmlIoUtils.MoveToElement(xr, false, __ElemRoot);
// Find <Mazes>
XmlIoUtils.MoveToElement(xr, true, __ElemMazes);
// Read mazes
List<MazeGenome> genomeList = new List<MazeGenome>();
using (XmlReader xrSubtree = xr.ReadSubtree())
{
// Re-scan for the root <Mazes> element
XmlIoUtils.MoveToElement(xrSubtree, false);
// Move to first Maze element
XmlIoUtils.MoveToElement(xrSubtree, true, __ElemMaze);
// Read maze elements
do
{
MazeGenome genome = ReadGenome(xrSubtree);
genomeList.Add(genome);
} while (xrSubtree.ReadToNextSibling(__ElemMaze));
}
// Check for empty list
if (genomeList.Count == 0)
{
return genomeList;
}
// Determine the max genome ID
uint maxGenomeId = genomeList.Aggregate<MazeGenome, uint>(0,
(current, genome) => Math.Max(current, genome.Id));
// Determine the max gene innovation ID
uint maxInnovationId = genomeList.Aggregate<MazeGenome, uint>(0,
(curMaxPopulationInnovationId, genome) =>
genome.GeneList.Aggregate(curMaxPopulationInnovationId,
(curMaxGenomeInnovationId, mazeGene) =>
Math.Max(curMaxGenomeInnovationId, mazeGene.InnovationId)));
// Set the genome factory ID generator and innovation ID generator to one more than the max
genomeFactory.GenomeIdGenerator.Reset(Math.Max(genomeFactory.GenomeIdGenerator.Peek, maxGenomeId + 1));
genomeFactory.InnovationIdGenerator.Reset(Math.Max(genomeFactory.InnovationIdGenerator.Peek,
maxInnovationId + 1));
// Retrospecitively assign the genome factory to the genomes
foreach (MazeGenome genome in genomeList)
{
genome.GenomeFactory = genomeFactory;
}
return genomeList;
}
public static IEnumerable<Message> ReadAllXml (XmlReader r)
{
while (r.Read ()) {
if (r.IsStartElement ("Message")) {
var m = new Message ();
m.ReadXml (r.ReadSubtree ());
yield return m;
}
}
}
public void ReadXml(XmlReader reader)
{
while (!reader.EOF)
{
if (reader.IsStartElement())
{
switch (reader.Name)
{
case FontFamiliesElementName:
ReadFonts(reader.ReadSubtree());
break;
case CSSElementsElementName:
ReadCSSElements(reader.ReadSubtree());
break;
}
}
reader.Read();
}
}
public virtual void ReadXml(XmlReader reader)
{
reader.MoveToContent();
XmlReader xr = reader.ReadSubtree();
while (!xr.EOF)
{
xr.MoveToContent();
_parameters.Add(xr.GetAttribute("key"), xr.Value);
}
}
public void ReadXml(System.Xml.XmlReader r)
{
using (XmlReader reader = r.ReadSubtree()) {
if (reader.Read())
{
while (reader.Read())
{
if (reader.NodeType == System.Xml.XmlNodeType.Element && !reader.IsEmptyElement)
{
EntityDbField field = new EntityDbField(
XmlConvert.EncodeLocalName(reader.LocalName),
(SqlDbType)Enum.Parse(typeof(SqlDbType), reader["dbType"]),
Int32.Parse(reader["length"]),
GetDbType());
int pos;
if ((pos = m_FieldMap.BinarySearch(new EntityFieldMapping(field))) >= 0)
{
if (m_FieldMap[pos].EntityField.FieldType == typeof(Byte[]))
{
using (MemoryStream ms = new MemoryStream()) {
Byte[] buffer = new Byte[1024];
int read = 0;
while ((read = reader.ReadElementContentAsBase64(buffer, 0, 1024)) > 0)
{
ms.Write(buffer, 0, read);
}
m_FieldMap[pos].EntityField.SetValue(this, ms.ToArray());
ms.Close();
}
}
else if (m_FieldMap[pos].EntityField.FieldType.IsGenericType && m_FieldMap[pos].EntityField.FieldType.GetGenericTypeDefinition() == typeof(Nullable <>))
{
if (m_FieldMap[pos].EntityField.FieldType.GetGenericArguments()[0] == typeof(Guid))
{
m_FieldMap[pos].EntityField.SetValue(this, new Guid(reader.ReadElementContentAsString()));
}
else
{
m_FieldMap[pos].EntityField.SetValue(this, reader.ReadElementContentAs(m_FieldMap[pos].EntityField.FieldType.GetGenericArguments()[0], null));
}
}
else
{
m_FieldMap[pos].EntityField.SetValue(this, reader.ReadElementContentAs(m_FieldMap[pos].EntityField.FieldType, null));
}
}
}
}
}
}
r.Read();
}
/// <summary>
/// 读取子属性
/// </summary>
/// <param name="reader"></param>
/// <param name="func"></param>
private void ReadSubProp(System.Xml.XmlReader reader, Action <DocumentProperty> func)
{
var part = new DocumentProperty();
var SubReader = reader.ReadSubtree();
SubReader.Read();
part.ReadXml(SubReader);
func(part);
reader.ReadEndElement();
reader.MoveToContent();
}
public RootFilter(XmlReader configuration) {
exposed = Convert.ToBoolean(configuration.GetAttribute("expose"));
XmlReader subtree = configuration.ReadSubtree();
while (subtree.Read()) {
if ((subtree.NodeType == XmlNodeType.Element) && (subtree.Name == "namespace")) {
NamespaceFilter namespaceFilter = new NamespaceFilter(subtree);
namespaceFilters.Add(namespaceFilter);
}
}
subtree.Close();
}
private static FaultCode Deserialize(XmlReader reader)
{
using (reader) {
var code = new FaultCode ();
reader.ReadToFollowing ("UPnPError", "urn:schemas-upnp-org:control-1-0");
while (Helper.ReadToNextElement (reader)) {
Deserialize (reader.ReadSubtree (), reader.Name, ref code);
}
return code;
}
}
internal override void Load (XmlReader reader)
{
while (reader.Read () && reader.NodeType != XmlNodeType.Element)
;
FillLocation (reader);
using (XmlReader subReader = reader.ReadSubtree ()) {
document = new XmlDocument ();
document.Load (subReader);
element = document.DocumentElement;
}
}
private static void HandleTopLevelElement(XmlReader reader, IPluginVisitor visitor)
{
if (reader.Name == "revisions" && visitor.EnterRevisions())
{
ReadRevisions(reader.ReadSubtree(), visitor);
visitor.LeaveRevisions();
}
else
{
HandleElement(reader, visitor);
}
}
public static YodiiEngine CreateEngineFromXml( XmlReader r )
{
YodiiEngine e = new YodiiEngine( new YodiiEngineHostMock() );
DiscoveredInfo d = new DiscoveredInfo();
// Used to index reference links between plugins and services.
List<PendingGeneralization> pendingGeneralizations = new List<PendingGeneralization>();
List<PendingPluginService> pendingPluginServices = new List<PendingPluginService>();
List<PendingServiceReference> pendingServiceReferences = new List<PendingServiceReference>();
CKSortedArrayKeyList<PluginInfo, string> loadedPlugins;
CKSortedArrayKeyList<ServiceInfo, string> loadedServices;
loadedServices = new CKSortedArrayKeyList<ServiceInfo, string>( s => s.ServiceFullName, false );
loadedPlugins = new CKSortedArrayKeyList<PluginInfo, string>( p => p.PluginFullName, false );
while( r.Read() )
{
// Load services
if( r.IsStartElement() && r.Name == "Services" )
{
ReadServices( r.ReadSubtree(), d, loadedServices, loadedPlugins, pendingGeneralizations, pendingPluginServices, pendingServiceReferences );
}
// Load plugins
if( r.IsStartElement() && r.Name == "Plugins" )
{
ReadPlugins( r.ReadSubtree(), d, loadedServices, loadedPlugins, pendingPluginServices, pendingServiceReferences );
}
// Read configuration manager
if( r.IsStartElement() && r.Name == "Configuration" )
{
ReadConfigurationManager( e.Configuration, r.ReadSubtree() );
}
}
e.SetDiscoveredInfo( d );
return e;
}
/// <summary>
/// Parses the XML and if there's an in-stream error in it it will return it.
/// </summary>
/// <param name="reader">The reader to read the XML from.</param>
/// <returns>If there was an in-stream error this will return it as an exception instance, otherwise it returns null.</returns>
public static Exception ParseInStreamError(XmlReader reader)
{
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element &&
reader.LocalName == "error" &&
reader.NamespaceURI == UnitTestsUtil.MetadataNamespace.NamespaceName)
{
return ParseInStreamSingleError(reader.ReadSubtree());
}
}
return null;
}
public void ReadXml(XmlReader reader)
{
if (reader.MoveToContent() == XmlNodeType.Element &&
reader.LocalName == "repeat")
{
index = int.Parse(reader["index"]);
if (reader.ReadToDescendant("template"))
template = XElement.Load(reader.ReadSubtree())
.Elements()
.First();
}
}
public TypeFilter(XmlReader configuration) {
if ((configuration.NodeType != XmlNodeType.Element) || (configuration.Name != "type")) throw new InvalidOperationException();
name = configuration.GetAttribute("name");
exposed = Convert.ToBoolean(configuration.GetAttribute("expose"));
XmlReader subtree = configuration.ReadSubtree();
while (subtree.Read()) {
if ((subtree.NodeType == XmlNodeType.Element) && (subtree.Name == "member")) {
MemberFilter memberFilter = new MemberFilter(subtree);
memberFilters.Add(memberFilter);
}
}
subtree.Close();
}
public void ReadXml(XmlReader reader)
{
reader.Read();
var sub = reader.ReadSubtree();
do
{
if (sub.NodeType == XmlNodeType.Element)
{
string name = sub.Name;
string val = sub.ReadElementContentAsString();
Values.Add(name, Convert.ToDouble(val));
}
} while (sub.Read());
}
internal override void ProcessXmlCore (XmlReader reader)
{
switch (reader.Name) {
case "title":
title = reader.ReadString ();
break;
case "artist":
artist = new Artist (reader.ReadSubtree ());
break;
default:
base.ProcessXmlCore (reader);
break;
}
}
public void ReadXml(System.Xml.XmlReader reader)
{
if (reader.ReadToFollowing(this.GetType().Name))
{
reader.ReadStartElement();
if (reader.LocalName == typeof(TabLayout).Name || reader.LocalName == "MultiContent") // MultiContent is old name and is used here for compatibility with old saved layouts
{
DockedContent = new TabLayout(Root, reader.ReadSubtree());
Content = DockedContent;
reader.ReadEndElement();
}
reader.ReadEndElement();
}
}
public void ReadXml(System.Xml.XmlReader reader)
{
reader.ReadToFollowing(xmlFlujogramaType.Name);
XmlSerializer serializer = new XmlSerializer(xmlFlujogramaType);
FlujogramaDef = serializer.Deserialize(reader) as IFlujograma;
//EntidadIDentificable.IdEntidad = FlujogramaDef.IdEntidad;
//EntidadIDentificable.Entidad = FlujogramaDef.Entidad;
reader.ReadToFollowing(xmlEstadoType.Name);
if (reader.Name.Equals(xmlEstadoType.Name))
{
serializer = new XmlSerializer(xmlEstadoType);
EstadoActual = serializer.Deserialize(reader) as IEstado;
EstadoActual.Flujograma = FlujogramaDef;
}
reader.ReadToFollowing(xmlTransicionType.Name);
if (reader.Name.Equals(xmlTransicionType.Name))
{
serializer = new XmlSerializer(xmlTransicionType);
UltimaTransicion = serializer.Deserialize(reader) as ITransicion;
UltimaTransicion.Flujograma = FlujogramaDef;
UltimaTransicion.Origen = FlujogramaDef.Estados[UltimaTransicion.Origen.Estado];
UltimaTransicion.Destino = FlujogramaDef.Estados[UltimaTransicion.Destino.Estado];
}
reader.ReadToFollowing("Historico");
if (reader.Name.Equals("Historico"))
{
XmlReader hijos = reader.ReadSubtree();
serializer = new XmlSerializer(xmlTransicionType);
while (hijos.ReadToFollowing(xmlTransicionType.Name))
{
ITransicion tran = serializer.Deserialize(hijos) as ITransicion;
tran.Flujograma = FlujogramaDef;
tran.Origen = FlujogramaDef.Estados[tran.Origen.Estado];
tran.Destino = FlujogramaDef.Estados[tran.Destino.Estado];
_procesosAnteriores.Add(tran.FechaTransicion, tran);
}
}
}
private void ReadBackground(ref XmlReadState state, System.Xml.XmlReader node)
{
node.Read();
if (!state.Silent)
{
Console.WriteLine("Background shader");
}
var shader = new Shader(Client, Shader.ShaderType.World)
{
Name = Guid.NewGuid().ToString()
};
Utilities.Instance.ReadNodeGraph(ref shader, node.ReadSubtree());
state.Scene.AddShader(shader);
state.Scene.Background.Shader = shader;
}
public void ReadXml(System.Xml.XmlReader reader)
{
if (reader == null)
{
throw new ArgumentNullException("reader");
}
if (reader.LocalName == "Settings")
{
XmlReader topReader = reader.ReadSubtree();
XPathDocument doc = new XPathDocument(topReader);
var nav = doc.CreateNavigator();
XPathNavigator iter = nav.SelectSingleNode("/Settings/Version");
if (iter == null)
{
throw new XmlSchemaException("Settings does not have a version element");
}
}
}
public void ReadShader(ref XmlReadState state, System.Xml.XmlReader node)
{
node.Read();
var name = node.GetAttribute("name");
if (!state.Silent)
{
Console.WriteLine("Shader: {0}", node.GetAttribute("name"));
}
if (string.IsNullOrEmpty(name))
{
return;
}
var shader = new Shader(Client, Shader.ShaderType.Material)
{
Name = name
};
Utilities.Instance.ReadNodeGraph(ref shader, node.ReadSubtree());
state.Scene.AddShader(shader);
}
public new void ReadXml(System.Xml.XmlReader reader)
{
while (reader.Read())
{
base.ReadXml(reader);
if (reader.NodeType == System.Xml.XmlNodeType.Element)
{
switch (reader.Name)
{
case "PollType":
this.PollType = (QuestionPollType)reader.ReadString().ToInt32(1);
break;
case "AnonymousAllowed":
AnonymousAllowed = bool.Parse(reader.ReadString());
break;
case "ShowResult":
ShowResult = (QuestionShowResult)reader.ReadString().ToInt32(1);
break;
case "ShowAnswerCount":
ShowAnswerCount = (QuestionShowAnswerCount)reader.ReadString().ToInt32(1);
break;
case "PollLayout":
PollLayout = (QuestionPollLayout)reader.ReadString().ToInt32(1);
break;
case "TextRight":
TextRight = reader.ReadString();
break;
case "TextFalse":
TextFalse = reader.ReadString();
break;
case "TextPartially":
TextPartially = reader.ReadString();
break;
case "Answers":
PollAnswer item = null;
System.Xml.XmlReader subReader = reader.ReadSubtree();
while (subReader.Read())
{
if (subReader.NodeType == System.Xml.XmlNodeType.Element)
{
if (subReader.Name == "Answer")
{
if (item != null)
{
list.Add(item);
}
item = new PollAnswer();
item.Answer = subReader.ReadString();
}
}
else if (subReader.NodeType == System.Xml.XmlNodeType.Attribute)
{
switch (subReader.Name)
{
case "Position":
item.Position = Convert.ToInt32(subReader.ReadString());
break;
case "Anonnymous":
item.Anonnymous = Convert.ToInt32(subReader.ReadString());
break;
case "Registerd":
item.Registerd = Convert.ToInt32(subReader.ReadString());
break;
case "IsRight":
item.IsRight = Convert.ToBoolean(subReader.ReadString());
break;
}
}
}
break;
}
}
}
}
private static ITestCommand ReadTestCommand(System.Xml.XmlReader reader, string comment, string sessionId)
{
var cmd = ReadCommand(reader, comment, sessionId);
if (cmd != null)
{
return(cmd);
}
switch (reader.LocalName)
{
case "AssertMatch":
var result = new AssertMatch()
{
Comment = comment,
Match = reader.GetAttribute("match")
};
var removeSys = reader.GetAttribute("removeSysProps");
result.RemoveSystemProperties = (removeSys != "0");
using (var subReader = reader.ReadSubtree())
{
subReader.Read();
while (!subReader.EOF)
{
if (reader.NodeType == XmlNodeType.Element)
{
switch (reader.LocalName)
{
case "Remove":
result.Removes.Add(reader.GetAttribute("match"));
subReader.Read();
break;
case "Expected":
bool isXml;
result.Expected = ProcessXmlValue(reader.ReadInnerXml(), out isXml);
result.IsXml = isXml;
break;
default:
subReader.Read();
break;
}
}
else
{
subReader.Read();
}
}
}
reader.Read();
return(result);
case "DownloadFile":
return(new DownloadFile()
{
Comment = comment,
Text = reader.ReadInnerXml()
});
}
return(null);
}
public void ReadFrom(System.Xml.XmlReader x)
{
XmlReader s = null;
while (x.Read())
{
switch (x.LocalName)
{
case "BinaryPath":
BinPath = x.ReadString();
break;
case "TargetConfiguration":
s = x.ReadSubtree();
var t = new LinkTargetConfiguration();
if (t.LoadFrom(this, s))
{
LinkTargetConfigurations [t.TargetType] = t;
}
s.Close();
break;
case "DefaultLibs":
s = x.ReadSubtree();
while (s.Read())
{
if (s.LocalName == "lib")
{
DefaultLibraries.Add(s.ReadString());
}
}
s.Close();
break;
case "Includes":
s = x.ReadSubtree();
while (s.Read())
{
if (s.LocalName == "Path")
{
ParseCache.ParsedDirectories.Add(s.ReadString());
}
}
s.Close();
break;
case "VersionId":
PredefinedVersionConstant = x.ReadString();
break;
case "CompilerCommand":
SourceCompilerCommand = x.ReadString();
break;
case "Patterns":
s = x.ReadSubtree();
ArgumentPatterns.ReadFrom(s);
s.Close();
break;
case "gdcLibPrefixing":
EnableGDCLibPrefixing = x.ReadString() == "true";
break;
}
}
}
private void ReadScene(ref XmlReadState state, System.Xml.XmlReader node)
{
while (node.Read())
{
if (!node.IsStartElement())
{
continue;
}
if (!state.Silent)
{
Console.WriteLine("XML node: {0}", node.Name);
}
switch (node.Name)
{
case "camera":
ReadCamera(ref state, node.ReadSubtree());
break;
case "background":
ReadBackground(ref state, node.ReadSubtree());
break;
case "transform":
var transform_substate = new XmlReadState(state);
var t = transform_substate.Transform;
ReadTransform(node, ref t);
transform_substate.Transform = t;
node.Read(); /* advance forward one, otherwise we'll end up in internal loop */
ReadScene(ref transform_substate, node.ReadSubtree());
break;
case "lookat":
var lookat_substate = new XmlReadState(state);
var lat = lookat_substate.Transform;
ReadLookAt(node, ref lat);
lookat_substate.Transform = lat;
node.Read(); /* advance forward one, otherwise we'll end up in internal loop */
ReadScene(ref lookat_substate, node.ReadSubtree());
break;
case "state":
var state_substate = new XmlReadState(state);
ReadState(ref state_substate, node.ReadSubtree());
node.Read(); /* advance one forward */
ReadScene(ref state_substate, node.ReadSubtree());
break;
case "integrator":
ReadIntegrator(ref state, node.ReadSubtree());
break;
case "shader":
var shader_substate = new XmlReadState(state);
ReadShader(ref shader_substate, node.ReadSubtree());
break;
case "mesh":
ReadMesh(ref state, node.ReadSubtree());
break;
case "object":
ReadObject(ref state, node.ReadSubtree());
break;
case "light":
ReadLight(ref state, node.ReadSubtree());
break;
case "include":
var src = node.GetAttribute("src");
if (!string.IsNullOrEmpty(src))
{
ReadInclude(ref state, src);
}
break;
default:
Console.WriteLine("Uknown node {0}", node.Name);
break;
}
}
}
public void ReadXml(System.Xml.XmlReader reader)
{
if (reader.ReadToFollowing(this.GetType().Name))
{
String s = reader.GetAttribute(Orientation.GetType().Name);
m_orientation = (Orientation)(Enum.Parse(Orientation.GetType(), s));
switch (m_orientation)
{
case Orientation.Horizontal:
if (reader.ReadToDescendant("Column"))
{
RowDefinitions.Add(NewRowDefinition(new GridLength(1, GridUnitType.Star), m_minGridSize.Height));
do
{
double width = double.Parse(reader.GetAttribute("Width"));
IDockLayout layout = null;
reader.ReadStartElement();
if (reader.LocalName == typeof(DockedWindow).Name)
{
DockedWindow dockedWindow = new DockedWindow(Root, reader.ReadSubtree());
layout = dockedWindow.DockedContent.Children.Count != 0 ? dockedWindow : null;
reader.ReadEndElement();
}
else if (reader.LocalName == typeof(GridLayout).Name)
{
GridLayout gridLayout = new GridLayout(Root, reader.ReadSubtree());
layout = gridLayout.Layouts.Count > 0 ? gridLayout : null;
reader.ReadEndElement();
}
if (layout != null)
{
if (Children.Count > 0)
{
ColumnDefinitions.Add(NewColumnDefinition(new GridLength(1, GridUnitType.Auto), 0));
Children.Add(NewGridSplitter(Orientation));
}
ColumnDefinitions.Add(NewColumnDefinition(new GridLength(width, GridUnitType.Star), m_minGridSize.Width));
m_children.Add(layout);
Children.Add((FrameworkElement)layout);
}
} while (reader.ReadToNextSibling("Column"));
}
break;
case Orientation.Vertical:
if (reader.ReadToDescendant("Row"))
{
ColumnDefinitions.Add(NewColumnDefinition(new GridLength(1, GridUnitType.Star), m_minGridSize.Width));
do
{
double height = double.Parse(reader.GetAttribute("Height"));
IDockLayout layout = null;
reader.ReadStartElement();
if (reader.LocalName == typeof(DockedWindow).Name)
{
DockedWindow dockedWindow = new DockedWindow(Root, reader.ReadSubtree());
layout = dockedWindow.DockedContent.Children.Count != 0 ? dockedWindow : null;
reader.ReadEndElement();
}
else if (reader.LocalName == typeof(GridLayout).Name)
{
GridLayout gridLayout = new GridLayout(Root, reader.ReadSubtree());
layout = gridLayout.Layouts.Count > 0 ? gridLayout : null;
reader.ReadEndElement();
}
if (layout != null)
{
if (Children.Count > 0)
{
RowDefinitions.Add(NewRowDefinition(new GridLength(1, GridUnitType.Auto), 0));
Children.Add(NewGridSplitter(Orientation));
}
RowDefinitions.Add(NewRowDefinition(new GridLength(height, GridUnitType.Star), m_minGridSize.Height));
m_children.Add(layout);
Children.Add((FrameworkElement)layout);
}
} while (reader.ReadToNextSibling("Row"));
}
break;
}
for (int i = 0; i < Children.Count; i++)
{
Grid.SetColumn(Children[i], Orientation == Orientation.Horizontal ? i : 0);
Grid.SetRow(Children[i], Orientation == Orientation.Vertical ? i : 0);
}
reader.ReadEndElement();
}
}
public override void ReadXml(System.Xml.XmlReader reader)
{
using (System.Xml.XmlReader subTree = reader.ReadSubtree()) {
subTree.Read();
string tmp = subTree.ReadOuterXml();
//seek for template tag
using (XmlReader xr = new XmlTextReader(tmp, XmlNodeType.Element, null)) {
xr.Read();
base.ReadXml(xr);
}
//process content
using (XmlReader xr = new XmlTextReader(tmp, XmlNodeType.Element, null)) {
xr.Read(); //skip current node
while (!xr.EOF)
{
xr.Read(); //read first child
if (!xr.IsStartElement())
{
continue;
}
if (xr.Name == "Template")
{
xr.Skip();
if (!xr.IsStartElement())
{
continue;
}
}
Type t = Type.GetType("Crow." + xr.Name);
if (t == null)
{
Assembly a = Assembly.GetEntryAssembly();
foreach (Type expT in a.GetExportedTypes())
{
if (expT.Name == xr.Name)
{
t = expT;
}
}
}
if (t == null)
{
throw new Exception(xr.Name + " type not found");
}
GraphicObject go = (GraphicObject)Activator.CreateInstance(t);
(go as IXmlSerializable).ReadXml(xr);
Content = go;
xr.Read(); //closing tag
}
}
}
}
public override void ReadXml(System.Xml.XmlReader reader)
{
//Template could be either an attribute containing path or expressed inlined
//as a Template Element
using (System.Xml.XmlReader subTree = reader.ReadSubtree())
{
subTree.Read();
string template = reader.GetAttribute("Template");
string tmp = subTree.ReadOuterXml();
//Load template from path set as attribute in templated control
if (string.IsNullOrEmpty(template))
{
//seek for template tag first
using (XmlReader xr = new XmlTextReader(tmp, XmlNodeType.Element, null)) {
//load template first if inlined
xr.Read(); //read first child
xr.Read(); //skip root node
while (!xr.EOF)
{
if (!xr.IsStartElement())
{
xr.Read();
continue;
}
if (xr.Name == "ItemTemplate")
{
string dataType = "default", datas = "", itemTmp;
while (xr.MoveToNextAttribute())
{
if (xr.Name == "DataType")
{
dataType = xr.Value;
}
else if (xr.Name == "Data")
{
datas = xr.Value;
}
}
xr.MoveToElement();
itemTmp = xr.ReadInnerXml();
if (ItemTemplates == null)
{
ItemTemplates = new Dictionary <string, ItemTemplate> ();
}
using (IMLReader iTmp = new IMLReader(null, itemTmp)) {
ItemTemplates [dataType] =
new ItemTemplate(iTmp.RootType, iTmp.GetLoader(), dataType, datas);
}
if (!string.IsNullOrEmpty(datas))
{
ItemTemplates [dataType].CreateExpandDelegate(this);
}
continue;
}
if (xr.Name == "Template")
{
xr.Read();
Type t = Type.GetType("Crow." + xr.Name);
if (t == null)
{
Assembly a = Assembly.GetEntryAssembly();
foreach (Type expT in a.GetExportedTypes())
{
if (expT.Name == xr.Name)
{
t = expT;
}
}
}
GraphicObject go = (GraphicObject)Activator.CreateInstance(t);
(go as IXmlSerializable).ReadXml(xr);
loadTemplate(go);
continue;
}
xr.ReadInnerXml();
}
}
}
else
{
loadTemplate(CurrentInterface.Load(template));
}
//if no template found, load default one
if (this.child == null)
{
loadTemplate();
}
//normal xml read
using (XmlReader xr = new XmlTextReader(tmp, XmlNodeType.Element, null)) {
xr.Read();
base.ReadXml(xr);
}
}
}
public new void ReadXml(System.Xml.XmlReader reader)
{
List <string> largePictures = new List <string>();
List <string> pictureCaptions = new List <string>();
while (reader.Read())
{
base.ReadXml(reader);
if (reader.NodeType == System.Xml.XmlNodeType.Element)
{
switch (reader.Name)
{
case "NewsText":
NewsText = reader.ReadString();
break;
case "NewsRefURL":
string url = reader.ReadString();
if (!string.IsNullOrEmpty(url))
{
ReferenceURL = new Uri(url);
}
break;
case "NewsPicList":
System.Xml.XmlReader picListReader = reader.ReadSubtree();
while (picListReader.Read())
{
if (picListReader.NodeType == System.Xml.XmlNodeType.Element)
{
switch (picListReader.Name)
{
case "Pic":
largePictures.Add(picListReader.ReadString());
break;
case "Caption":
pictureCaptions.Add(picListReader.ReadString());
break;
}
}
}
break;
case "Links":
List <Link> links = new List <Link>();
Link link = null;
System.Xml.XmlReader linksListReader = reader.ReadSubtree();
while (linksListReader.Read())
{
if (linksListReader.NodeType == System.Xml.XmlNodeType.Element)
{
switch (linksListReader.Name)
{
case "Link":
link = new Link();
break;
case "Title":
link.Title = linksListReader.ReadString().StripHTMLTags();
break;
case "URL":
string url2 = linksListReader.ReadString();
if (!string.IsNullOrEmpty(url2))
{
link.URL = new Uri(url2);
}
break;
}
}
if (link != null && !string.IsNullOrEmpty(link.Title) && link.URL != null)
{
links.Add(link);
link = null;
}
}
Links = links;
break;
}
}
}
LargePictures = largePictures;
PictureCaptions = pictureCaptions;
}
/// <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);
}
/// <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);
}
