private void LoadSchemaFromLocation(string uri)
{
// is x-schema
if (!XdrBuilder.IsXdrSchema(uri))
{
return;
}
string url = uri.Substring(x_schema.Length);
XmlReader? reader = null;
SchemaInfo?xdrSchema = null;
try
{
Uri ruri = this.XmlResolver !.ResolveUri(BaseUri, url);
Stream stm = (Stream)this.XmlResolver.GetEntity(ruri, null, null) !;
reader = new XmlTextReader(ruri.ToString(), stm, NameTable);
((XmlTextReader)reader).XmlResolver = this.XmlResolver;
Parser parser = new Parser(SchemaType.XDR, NameTable, SchemaNames, EventHandler);
parser.XmlResolver = this.XmlResolver;
parser.Parse(reader, uri);
while (reader.Read())
{
; // wellformness check
}
xdrSchema = parser.XdrSchema;
}
catch (XmlSchemaException e)
{
SendValidationEvent(SR.Sch_CannotLoadSchema, new string[] { uri, e.Message }, XmlSeverityType.Error);
}
catch (Exception e)
{
SendValidationEvent(SR.Sch_CannotLoadSchema, new string[] { uri, e.Message }, XmlSeverityType.Warning);
}
finally
{
if (reader != null)
{
reader.Close();
}
}
if (xdrSchema != null && xdrSchema.ErrorCount == 0)
{
schemaInfo !.Add(xdrSchema, EventHandler);
SchemaCollection !.Add(uri, xdrSchema, null, false);
}
}
public void StartParsing(XmlReader reader, string?targetNamespace)
{
_reader = reader;
_positionInfo = PositionInfo.GetPositionInfo(reader);
_namespaceManager = reader.NamespaceManager;
if (_namespaceManager == null)
{
_namespaceManager = new XmlNamespaceManager(_nameTable);
_isProcessNamespaces = true;
}
else
{
_isProcessNamespaces = false;
}
while (reader.NodeType != XmlNodeType.Element && reader.Read())
{
}
_markupDepth = int.MaxValue;
_schemaXmlDepth = reader.Depth;
SchemaType rootType = _schemaNames.SchemaTypeFromRoot(reader.LocalName, reader.NamespaceURI);
if (!CheckSchemaRoot(rootType, out string?code))
{
throw new XmlSchemaException(code, reader.BaseURI, _positionInfo.LineNumber, _positionInfo.LinePosition);
}
if (_schemaType == SchemaType.XSD)
{
_schema = new XmlSchema();
_schema.BaseUri = new Uri(reader.BaseURI !, UriKind.RelativeOrAbsolute);
_builder = new XsdBuilder(reader, _namespaceManager, _schema, _nameTable, _schemaNames, _eventHandler);
}
else
{
Debug.Assert(_schemaType == SchemaType.XDR);
_xdrSchema = new SchemaInfo();
_xdrSchema.SchemaType = SchemaType.XDR;
_builder = new XdrBuilder(reader, _namespaceManager, _xdrSchema, targetNamespace, _nameTable, _schemaNames, _eventHandler);
((XdrBuilder)_builder).XmlResolver = _xmlResolver;
}
}
internal XmlNamespaceManager ParsePartialContent(XmlNode parentNode, string innerxmltext, XmlNodeType nt)
{
//the function shouldn't be used to set innerxml for XmlDocument node
Debug.Assert(parentNode.NodeType != XmlNodeType.Document);
_doc = parentNode.OwnerDocument;
Debug.Assert(_doc != null);
XmlParserContext pc = GetContext(parentNode);
_reader = CreateInnerXmlReader(innerxmltext, nt, pc, _doc);
try
{
_preserveWhitespace = true;
bool bOrigLoading = _doc.IsLoading;
_doc.IsLoading = true;
if (nt == XmlNodeType.Entity)
{
XmlNode?node = null;
while (_reader.Read() && (node = LoadNodeDirect()) != null)
{
parentNode.AppendChildForLoad(node, _doc);
}
}
else
{
XmlNode?node = null;
while (_reader.Read() && (node = LoadNode(true)) != null)
{
parentNode.AppendChildForLoad(node, _doc);
}
}
_doc.IsLoading = bOrigLoading;
}
finally
{
_reader.Close();
}
return(pc.NamespaceManager !);
}
public static State LoadFromFile(string path)
{
if (File.Exists(path))
{
try
{
XmlSerializer?serializer = new XmlSerializer(typeof(State));
using (XmlReader? reader = XmlReader.Create(path))
{
return((State)serializer.Deserialize(reader));
}
}
catch (Exception ex)
{
Logger.Warn(ex, "Could not load app state file {0}", path);
return(new State());
}
}
return(new State());
}
internal void Load(XmlDocument doc, XmlReader reader, bool preserveWhitespace)
{
_doc = doc;
// perf: unwrap XmlTextReader if no one derived from it
if (reader.GetType() == typeof(System.Xml.XmlTextReader))
{
_reader = ((XmlTextReader)reader).Impl;
}
else
{
_reader = reader;
}
_preserveWhitespace = preserveWhitespace;
if (doc == null)
{
throw new ArgumentException(SR.Xdom_Load_NoDocument);
}
if (reader == null)
{
throw new ArgumentException(SR.Xdom_Load_NoReader);
}
doc.SetBaseURI(reader.BaseURI !);
if (reader.Settings != null &&
reader.Settings.ValidationType == ValidationType.Schema)
{
doc.Schemas = reader.Settings.Schemas;
}
if (_reader.ReadState != ReadState.Interactive)
{
if (!_reader.Read())
{
return;
}
}
LoadDocSequence(doc);
}
// Set new property value.
// Null value is passed for deleting a property.
// While initializing, we are not assigning new values, and so the dirty flag should
// stay untouched.
private void RecordNewBinding(PackageXmlEnum propertyenum, object?value, bool initializing, XmlReader?reader)
{
// If we are reading values from the package, reader cannot be null
Debug.Assert(!initializing || reader != null);
if (!initializing)
{
_package.ThrowIfReadOnly();
}
// Case of an existing property.
if (_propertyDictionary.ContainsKey(propertyenum))
{
// Parsing should detect redundant entries.
if (initializing)
{
throw new XmlException(SR.Format(SR.DuplicateCorePropertyName, reader !.Name),
null, ((IXmlLineInfo)reader).LineNumber, ((IXmlLineInfo)reader).LinePosition);
}
// Nullable<DateTime> values can be checked against null
if (value == null) // a deletion
{
_propertyDictionary.Remove(propertyenum);
}
else // an update
{
_propertyDictionary[propertyenum] = value;
}
// If the binding is an assignment rather than an initialization, set the dirty flag.
_dirty = !initializing;
}
// Case of an initial value being set for a property. If value is null, no need to do anything
else if (value != null)
{
_propertyDictionary.Add(propertyenum, value);
// If the binding is an assignment rather than an initialization, set the dirty flag.
_dirty = !initializing;
}
}
/// <summary>
/// Deserializes the XML document contained by the specified XmlReader.
/// </summary>
/// <param name="xmlReader"></param>
/// <typeparam name="TValue"></typeparam>
/// <returns></returns>
public static TValue?Deserialize <TValue>(XmlReader?xmlReader) =>
xmlReader is null
? default
: (TValue?)Deserialize(typeof(TValue), xmlReader);
/// <summary>
/// Deserializes the XML document contained by the specified XmlReader.
/// </summary>
/// <param name="xmlReader"></param>
/// <param name="verifyObjectName"></param>
/// <typeparam name="TValue"></typeparam>
/// <returns></returns>
public static TValue?Deserialize <TValue>(XmlReader?xmlReader, bool verifyObjectName = true) =>
xmlReader is null
? default
: (TValue?)Deserialize(typeof(TValue), xmlReader, verifyObjectName);
public XIncludeException(string?message, XmlReader?xmlReader) : base(AddLocationInfo(message, xmlReader)) => Init(xmlReader);
public static object?ReadXml(this XmlReader?xmlReader, Type type) => XmlHelper.Deserialize(type, xmlReader);
public static TValue?ReadXml <TValue>(this XmlReader?xmlReader) => XmlHelper.Deserialize <TValue>(xmlReader);
/// <summary>
/// Loads a file from the given xml reader.
/// </summary>
/// <param name="reader"></param>
/// <returns></returns>
public static File Load(XmlReader reader)
{
// init
File?result = null;
// locked?
if (_Current != null)
{
throw new NotSupportedException();
}
// lock
_Current = reader;
// try/catch
try
{
// read to first element
while (reader.NodeType != XmlNodeType.Element && !reader.EOF)
{
reader.Read();
}
// element present?
if (reader.NodeType == XmlNodeType.Element)
{
// namespace valid?
if (reader.NamespaceURI != NAMESPACE_URI)
{
throw new XmlException(string.Format("Unexpected namespace '{0}' encountered.", reader.NamespaceURI));
}
// version
var version = reader.GetAttribute("version");
Type?type = null;
switch (version)
{
case "1.0":
// type
switch (reader.LocalName)
{
case "style":
type = typeof(StyleFile);
break;
case "locale":
type = typeof(LocaleFile);
break;
}
break;
default:
throw new XmlException(string.Format("Version '{0}' is not supported.", version));
}
// type found?
if (type == null)
{
throw new XmlException(string.Format("Unexpected element '{0}' of version '{1}' encountered.", reader.LocalName, version));
}
// deserialize
var xs = new XmlSerializer(type);
xs.UnknownNode += XmlSerializer_UnknownNode;
xs.UnknownAttribute += XS_UnknownAttribute;
result = (File)xs.Deserialize(reader);
}
}
finally
{
// unlock
_Current = null;
}
// done
return(result ?? throw new InvalidOperationException());
}
public static TValue?ReadXml <TValue>(this XmlReader?xmlReader) => DataContractHelper.Deserialize <TValue>(xmlReader);