/// <summary>
/// Call handler for the current element
/// </summary>
/// <param name="reader"> XmlReader positioned at the element </param>
/// <returns> true if element content should be skipped </returns>
private bool ParseElement(XmlReader reader)
{
var elementNamespace = reader.NamespaceURI;
// for schema element that right under the schema, we just ignore them, since schema does not
// have metadataproperties
if (!Schema.IsParseableXmlNamespace(elementNamespace, true) &&
ParentElement != null)
{
return(AddOtherContent(reader));
}
if (HandleElement(reader))
{
return(false);
}
else
{
// we need to report an error if the namespace for this element is a target namespace for the xml schemas we are parsing against.
// otherwise we assume that this is either a valid 'any' element or that the xsd validator has generated an error
if (string.IsNullOrEmpty(elementNamespace) ||
Schema.IsParseableXmlNamespace(reader.NamespaceURI, false))
{
AddError(
ErrorCode.UnexpectedXmlElement, EdmSchemaErrorSeverity.Error, reader, Strings.UnexpectedXmlElement(reader.Name));
}
return(true);
}
}
/// <summary>
/// Call handler for the current attribute
/// </summary>
/// <param name="reader"> XmlReader positioned at the attribute </param>
private void ParseAttribute(XmlReader reader)
{
#if false
// the attribute value is schema invalid, just skip it; this avoids some duplicate errors at the expense of better error messages...
if (reader.SchemaInfo != null && reader.SchemaInfo.Validity == System.Xml.Schema.XmlSchemaValidity.Invalid)
{
continue;
}
#endif
var attributeNamespace = reader.NamespaceURI;
if (attributeNamespace == XmlConstants.AnnotationNamespace &&
reader.LocalName == XmlConstants.UseStrongSpatialTypes &&
!ProhibitAttribute(attributeNamespace, reader.LocalName) &&
HandleAttribute(reader))
{
return;
}
else if (!Schema.IsParseableXmlNamespace(attributeNamespace, true))
{
AddOtherContent(reader);
}
else if (!ProhibitAttribute(attributeNamespace, reader.LocalName)
&&
HandleAttribute(reader))
{
return;
}
else if (reader.SchemaInfo == null ||
reader.SchemaInfo.Validity != XmlSchemaValidity.Invalid)
{
// there's no handler for (namespace,name) and there wasn't a validation error.
// Report an error of our own if the node is in no namespace or if it is in one of our xml schemas tartget namespace.
if (string.IsNullOrEmpty(attributeNamespace) ||
Schema.IsParseableXmlNamespace(attributeNamespace, true))
{
AddError(
ErrorCode.UnexpectedXmlAttribute, EdmSchemaErrorSeverity.Error, reader, Strings.UnexpectedXmlAttribute(reader.Name));
}
}
}
private bool AddOtherContent(XmlReader reader)
{
int lineNumber;
int linePosition;
GetPositionInfo(reader, out lineNumber, out linePosition);
MetadataProperty property;
if (reader.NodeType
== XmlNodeType.Element)
{
if (_schema.SchemaVersion == XmlConstants.EdmVersionForV1
||
_schema.SchemaVersion == XmlConstants.EdmVersionForV1_1)
{
// skip this element
// we don't support element annotations in v1 and v1.1
return(true);
}
// in V1 and V1.1 the codegen can only appear as the attribute annotation and we want to maintain
// the same behavior for V2, thus we throw if we encounter CodeGen namespace
// in structural annotation in V2 and furthur version
if (_schema.SchemaVersion >= XmlConstants.EdmVersionForV2 &&
reader.NamespaceURI == XmlConstants.CodeGenerationSchemaNamespace)
{
Debug.Assert(
XmlConstants.SchemaVersionLatest == XmlConstants.EdmVersionForV3,
"Please add checking for the latest namespace");
AddError(
ErrorCode.NoCodeGenNamespaceInStructuralAnnotation, EdmSchemaErrorSeverity.Error, lineNumber, linePosition,
Strings.NoCodeGenNamespaceInStructuralAnnotation(XmlConstants.CodeGenerationSchemaNamespace));
return(true);
}
Debug.Assert(
!Schema.IsParseableXmlNamespace(reader.NamespaceURI, false),
"Structural annotation cannot use any edm reserved namespaces");
// using this subtree aproach because when I call
// reader.ReadOuterXml() it positions me at the Node beyond
// the end of the node I am starting on
// which doesn't work with the parsing logic
using (var subtree = reader.ReadSubtree())
{
subtree.Read();
using (var stringReader = new StringReader(subtree.ReadOuterXml()))
{
var element = XElement.Load(stringReader);
property = CreateMetadataPropertyFromOtherNamespaceXmlArtifact(
element.Name.NamespaceName, element.Name.LocalName, element);
}
}
}
else
{
if (reader.NamespaceURI == XmlNamespaceNamespace)
{
// we don't bring in namespace definitions
return(true);
}
Debug.Assert(reader.NodeType == XmlNodeType.Attribute, "called an attribute function when not on an attribute");
property = CreateMetadataPropertyFromOtherNamespaceXmlArtifact(reader.NamespaceURI, reader.LocalName, reader.Value);
}
if (!OtherContent.Exists(mp => mp.Identity == property.Identity))
{
OtherContent.Add(property);
}
else
{
AddError(
ErrorCode.AlreadyDefined, EdmSchemaErrorSeverity.Error, lineNumber, linePosition,
Strings.DuplicateAnnotation(property.Identity, FQName));
}
return(false);
}
