private ValidatingReaderNodeData AddContent(XmlNodeType nodeType)
{
Debug.Assert(_contentIndex <= _contentEvents.Length);
ValidatingReaderNodeData contentInfo = _contentEvents[_contentIndex];
if (contentInfo != null)
{
contentInfo.Clear(nodeType);
_contentIndex++;
return(contentInfo);
}
if (_contentIndex >= _contentEvents.Length - 1)
{ //reached capacity of array, Need to increase capacity to twice the initial
ValidatingReaderNodeData[] newContentEvents = new ValidatingReaderNodeData[_contentEvents.Length * 2];
Array.Copy(_contentEvents, newContentEvents, _contentEvents.Length);
_contentEvents = newContentEvents;
}
contentInfo = _contentEvents[_contentIndex];
if (contentInfo == null)
{
contentInfo = new ValidatingReaderNodeData(nodeType);
_contentEvents[_contentIndex] = contentInfo;
}
_contentIndex++;
return(contentInfo);
}
private ValidatingReaderNodeData AddContent(XmlNodeType nodeType)
{
ValidatingReaderNodeData data = this.contentEvents[this.contentIndex];
if (data != null)
{
data.Clear(nodeType);
this.contentIndex++;
return(data);
}
if (this.contentIndex >= (this.contentEvents.Length - 1))
{
ValidatingReaderNodeData[] destinationArray = new ValidatingReaderNodeData[this.contentEvents.Length * 2];
Array.Copy(this.contentEvents, 0, destinationArray, 0, this.contentEvents.Length);
this.contentEvents = destinationArray;
}
data = this.contentEvents[this.contentIndex];
if (data == null)
{
data = new ValidatingReaderNodeData(nodeType);
this.contentEvents[this.contentIndex] = data;
}
this.contentIndex++;
return(data);
}
// Moves to the attribute with the specified index.
public override void MoveToAttribute(int i)
{
if (i < 0 || i >= attributeCount)
{
throw new ArgumentOutOfRangeException("i");
}
currentAttrIndex = i;
cachedNode = attributeEvents[i];
}
// Moves to the attribute with the specified index.
public override void MoveToAttribute(int i)
{
if (i < 0 || i >= _attributeCount)
{
throw new ArgumentOutOfRangeException(nameof(i));
}
_currentAttrIndex = i;
_cachedNode = _attributeEvents[i];
}
public override bool MoveToNextAttribute()
{
if ((this.currentAttrIndex + 1) < this.attributeCount)
{
this.cachedNode = this.attributeEvents[++this.currentAttrIndex];
return(true);
}
return(false);
}
internal ValidatingReaderNodeData RecordTextNode(string textValue, string originalStringValue, int depth, int lineNo, int linePos)
{
ValidatingReaderNodeData textNode = AddContent(XmlNodeType.Text);
textNode.SetItemData(textValue, originalStringValue);
textNode.SetLineInfo(lineNo, linePos);
textNode.Depth = depth;
return(textNode);
}
public override void MoveToAttribute(int i)
{
if ((i < 0) || (i >= this.attributeCount))
{
throw new ArgumentOutOfRangeException("i");
}
this.currentAttrIndex = i;
this.cachedNode = this.attributeEvents[i];
}
// Moves to the next attribute.
public override bool MoveToNextAttribute()
{
if (_currentAttrIndex + 1 < _attributeCount)
{
_cachedNode = _attributeEvents[++_currentAttrIndex];
return(true);
}
return(false);
}
internal void SwitchTextNodeAndEndElement(string textValue, string originalStringValue)
{
ValidatingReaderNodeData data = this.RecordTextNode(textValue, originalStringValue, this.coreReader.Depth + 1, 0, 0);
int index = this.contentIndex - 2;
ValidatingReaderNodeData data2 = this.contentEvents[index];
this.contentEvents[index] = data;
this.contentEvents[this.contentIndex - 1] = data2;
}
public override bool ReadAttributeValue()
{
if (this.cachedNode.NodeType != XmlNodeType.Attribute)
{
return(false);
}
this.cachedNode = this.CreateDummyTextNode(this.cachedNode.RawValue, this.cachedNode.Depth + 1);
return(true);
}
// Parses the attribute value into one or more Text and/or EntityReference node types.
public override bool ReadAttributeValue()
{
Debug.Assert(_cacheState == CachingReaderState.Replay);
if (_cachedNode.NodeType != XmlNodeType.Attribute)
{
return(false);
}
_cachedNode = CreateDummyTextNode(_cachedNode.RawValue, _cachedNode.Depth + 1);
return(true);
}
public override bool MoveToFirstAttribute()
{
if (this.attributeCount == 0)
{
return(false);
}
this.currentAttrIndex = 0;
this.cachedNode = this.attributeEvents[0];
return(true);
}
private ValidatingReaderNodeData CreateDummyTextNode(string attributeValue, int depth)
{
if (_textNode == null)
{
_textNode = new ValidatingReaderNodeData(XmlNodeType.Text);
}
_textNode.Depth = depth;
_textNode.RawValue = attributeValue;
return(_textNode);
}
// Moves to the first attribute.
public override bool MoveToFirstAttribute()
{
if (_attributeCount == 0)
{
return(false);
}
_currentAttrIndex = 0;
_cachedNode = _attributeEvents[0];
return(true);
}
internal void RecordEndElementNode()
{
ValidatingReaderNodeData data = this.AddContent(XmlNodeType.EndElement);
data.SetItemData(this.coreReader.LocalName, this.coreReader.Prefix, this.coreReader.NamespaceURI, this.coreReader.Depth);
data.SetLineInfo(this.coreReader as IXmlLineInfo);
if (this.coreReader.IsEmptyElement)
{
this.readAhead = true;
}
}
internal void SwitchTextNodeAndEndElement(string textValue, string originalStringValue)
{
Debug.Assert(_coreReader.NodeType == XmlNodeType.EndElement || (_coreReader.NodeType == XmlNodeType.Element && _coreReader.IsEmptyElement));
ValidatingReaderNodeData textNode = RecordTextNode(textValue, originalStringValue, _coreReader.Depth + 1, 0, 0);
int endElementIndex = _contentIndex - 2;
ValidatingReaderNodeData endElementNode = _contentEvents[endElementIndex];
Debug.Assert(endElementNode.NodeType == XmlNodeType.EndElement);
_contentEvents[endElementIndex] = textNode;
_contentEvents[_contentIndex - 1] = endElementNode;
}
internal void RecordEndElementNode()
{
ValidatingReaderNodeData recordedNode = AddContent(XmlNodeType.EndElement);
Debug.Assert(_coreReader.NodeType == XmlNodeType.EndElement || (_coreReader.NodeType == XmlNodeType.Element && _coreReader.IsEmptyElement));
recordedNode.SetItemData(_coreReader.LocalName, _coreReader.Prefix, _coreReader.NamespaceURI, _coreReader.Depth);
recordedNode.SetLineInfo(_coreReader as IXmlLineInfo);
if (_coreReader.IsEmptyElement)
{ //Simulated endElement node for <e/>, the coreReader is on cached Element node itself.
_readAhead = true;
}
}
public override string GetAttribute(string name, string namespaceURI)
{
namespaceURI = (namespaceURI == null) ? string.Empty : this.coreReaderNameTable.Get(namespaceURI);
name = this.coreReaderNameTable.Get(name);
for (int i = 0; i < this.attributeCount; i++)
{
ValidatingReaderNodeData data = this.attributeEvents[i];
if (Ref.Equal(data.LocalName, name) && Ref.Equal(data.Namespace, namespaceURI))
{
return(data.RawValue);
}
}
return(null);
}
private int GetAttributeIndexWithPrefix(string name)
{
name = this.coreReaderNameTable.Get(name);
if (name != null)
{
for (int i = 0; i < this.attributeCount; i++)
{
ValidatingReaderNodeData data = this.attributeEvents[i];
if (Ref.Equal(data.GetAtomizedNameWPrefix(this.coreReaderNameTable), name))
{
return(i);
}
}
}
return(-1);
}
public override bool MoveToAttribute(string name, string ns)
{
ns = (ns == null) ? string.Empty : this.coreReaderNameTable.Get(ns);
name = this.coreReaderNameTable.Get(name);
for (int i = 0; i < this.attributeCount; i++)
{
ValidatingReaderNodeData data = this.attributeEvents[i];
if (Ref.Equal(data.LocalName, name) && Ref.Equal(data.Namespace, ns))
{
this.currentAttrIndex = i;
this.cachedNode = this.attributeEvents[i];
return(true);
}
}
return(false);
}
private int GetAttributeIndexWithoutPrefix(string name)
{
name = this.coreReaderNameTable.Get(name);
if (name != null)
{
for (int i = 0; i < this.attributeCount; i++)
{
ValidatingReaderNodeData data = this.attributeEvents[i];
if (Ref.Equal(data.LocalName, name) && (data.Prefix.Length == 0))
{
return(i);
}
}
}
return(-1);
}
private void RecordAttributes()
{
this.attributeCount = this.coreReader.AttributeCount;
if (this.coreReader.MoveToFirstAttribute())
{
int attIndex = 0;
do
{
ValidatingReaderNodeData data = this.AddAttribute(attIndex);
data.SetItemData(this.coreReader.LocalName, this.coreReader.Prefix, this.coreReader.NamespaceURI, this.coreReader.Depth);
data.SetLineInfo(this.lineInfo);
data.RawValue = this.coreReader.Value;
attIndex++;
}while (this.coreReader.MoveToNextAttribute());
this.coreReader.MoveToElement();
}
}
private void Init() {
coreReaderNameTable = coreReader.NameTable;
cacheState = CachingReaderState.Init;
contentIndex = 0;
currentAttrIndex = -1;
currentContentIndex = -1;
attributeCount = 0;
cachedNode = null;
readAhead = false;
//Initialize the cachingReader with start state
if (coreReader.NodeType == XmlNodeType.Element) {
ValidatingReaderNodeData element = AddContent(coreReader.NodeType);
element.SetItemData(coreReader.LocalName, coreReader.Prefix, coreReader.NamespaceURI, coreReader.Depth); //Only created for element node type
element.SetLineInfo(lineInfo);
RecordAttributes();
}
}
private void Init()
{
this.coreReaderNameTable = this.coreReader.NameTable;
this.cacheState = CachingReaderState.Init;
this.contentIndex = 0;
this.currentAttrIndex = -1;
this.currentContentIndex = -1;
this.attributeCount = 0;
this.cachedNode = null;
this.readAhead = false;
if (this.coreReader.NodeType == XmlNodeType.Element)
{
ValidatingReaderNodeData data = this.AddContent(this.coreReader.NodeType);
data.SetItemData(this.coreReader.LocalName, this.coreReader.Prefix, this.coreReader.NamespaceURI, this.coreReader.Depth);
data.SetLineInfo(this.lineInfo);
this.RecordAttributes();
}
}
private void Init()
{
_coreReaderNameTable = _coreReader.NameTable;
_cacheState = CachingReaderState.Init;
_contentIndex = 0;
_currentAttrIndex = -1;
_currentContentIndex = -1;
_attributeCount = 0;
_cachedNode = null;
_readAhead = false;
//Initialize the cachingReader with start state
if (_coreReader.NodeType == XmlNodeType.Element)
{
ValidatingReaderNodeData element = AddContent(_coreReader.NodeType);
element.SetItemData(_coreReader.LocalName, _coreReader.Prefix, _coreReader.NamespaceURI, _coreReader.Depth); //Only created for element node type
element.SetLineInfo(_lineInfo);
RecordAttributes();
}
}
// Moves to the attribute with the specified LocalName and NamespaceURI
public override bool MoveToAttribute(string name, string ns)
{
ns = (ns == null) ? string.Empty : _coreReaderNameTable.Get(ns);
name = _coreReaderNameTable.Get(name);
ValidatingReaderNodeData attribute;
for (int i = 0; i < _attributeCount; i++)
{
attribute = _attributeEvents[i];
if (Ref.Equal(attribute.LocalName, name) &&
Ref.Equal(attribute.Namespace, ns))
{
_currentAttrIndex = i;
_cachedNode = _attributeEvents[i];
return(true);
}
}
return(false);
}
public override bool MoveToAttribute(string name)
{
int attributeIndexWithoutPrefix;
if (name.IndexOf(':') == -1)
{
attributeIndexWithoutPrefix = this.GetAttributeIndexWithoutPrefix(name);
}
else
{
attributeIndexWithoutPrefix = this.GetAttributeIndexWithPrefix(name);
}
if (attributeIndexWithoutPrefix >= 0)
{
this.currentAttrIndex = attributeIndexWithoutPrefix;
this.cachedNode = this.attributeEvents[attributeIndexWithoutPrefix];
return(true);
}
return(false);
}
private ValidatingReaderNodeData AddAttribute(int attIndex)
{
ValidatingReaderNodeData data = this.attributeEvents[attIndex];
if (data != null)
{
data.Clear(XmlNodeType.Attribute);
return data;
}
if (attIndex >= (this.attributeEvents.Length - 1))
{
ValidatingReaderNodeData[] destinationArray = new ValidatingReaderNodeData[this.attributeEvents.Length * 2];
Array.Copy(this.attributeEvents, 0, destinationArray, 0, this.attributeEvents.Length);
this.attributeEvents = destinationArray;
}
data = this.attributeEvents[attIndex];
if (data == null)
{
data = new ValidatingReaderNodeData(XmlNodeType.Attribute);
this.attributeEvents[attIndex] = data;
}
return data;
}
private ValidatingReaderNodeData AddAttribute(int attIndex)
{
ValidatingReaderNodeData data = this.attributeEvents[attIndex];
if (data != null)
{
data.Clear(XmlNodeType.Attribute);
return(data);
}
if (attIndex >= (this.attributeEvents.Length - 1))
{
ValidatingReaderNodeData[] destinationArray = new ValidatingReaderNodeData[this.attributeEvents.Length * 2];
Array.Copy(this.attributeEvents, 0, destinationArray, 0, this.attributeEvents.Length);
this.attributeEvents = destinationArray;
}
data = this.attributeEvents[attIndex];
if (data == null)
{
data = new ValidatingReaderNodeData(XmlNodeType.Attribute);
this.attributeEvents[attIndex] = data;
}
return(data);
}
// Moves to the attribute with the specified Name.
public override bool MoveToAttribute(string name)
{
int i;
if (name.IndexOf(':') == -1)
{
i = GetAttributeIndexWithoutPrefix(name);
}
else
{
i = GetAttributeIndexWithPrefix(name);
}
if (i >= 0)
{
currentAttrIndex = i;
cachedNode = attributeEvents[i];
return(true);
}
else
{
return(false);
}
}
private ValidatingReaderNodeData AddAttribute(int attIndex)
{
Debug.Assert(attIndex <= _attributeEvents.Length);
ValidatingReaderNodeData attInfo = _attributeEvents[attIndex];
if (attInfo != null)
{
attInfo.Clear(XmlNodeType.Attribute);
return(attInfo);
}
if (attIndex >= _attributeEvents.Length - 1)
{ //reached capacity of array, Need to increase capacity to twice the initial
ValidatingReaderNodeData[] newAttributeEvents = new ValidatingReaderNodeData[_attributeEvents.Length * 2];
Array.Copy(_attributeEvents, newAttributeEvents, _attributeEvents.Length);
_attributeEvents = newAttributeEvents;
}
attInfo = _attributeEvents[attIndex];
if (attInfo == null)
{
attInfo = new ValidatingReaderNodeData(XmlNodeType.Attribute);
_attributeEvents[attIndex] = attInfo;
}
return(attInfo);
}
private ValidatingReaderNodeData AddContent(XmlNodeType nodeType)
{
ValidatingReaderNodeData data = this.contentEvents[this.contentIndex];
if (data != null)
{
data.Clear(nodeType);
this.contentIndex++;
return data;
}
if (this.contentIndex >= (this.contentEvents.Length - 1))
{
ValidatingReaderNodeData[] destinationArray = new ValidatingReaderNodeData[this.contentEvents.Length * 2];
Array.Copy(this.contentEvents, 0, destinationArray, 0, this.contentEvents.Length);
this.contentEvents = destinationArray;
}
data = this.contentEvents[this.contentIndex];
if (data == null)
{
data = new ValidatingReaderNodeData(nodeType);
this.contentEvents[this.contentIndex] = data;
}
this.contentIndex++;
return data;
}
// Moves to the attribute with the specified Name.
public override bool MoveToAttribute(string name)
{
int i;
if (!name.Contains(':'))
{
i = GetAttributeIndexWithoutPrefix(name);
}
else
{
i = GetAttributeIndexWithPrefix(name);
}
if (i >= 0)
{
_currentAttrIndex = i;
_cachedNode = _attributeEvents[i];
return(true);
}
else
{
return(false);
}
}
// Moves to the next attribute.
public override bool MoveToNextAttribute()
{
if (_currentAttrIndex + 1 < _coreReaderAttributeCount)
{
bool moveTo = _coreReader.MoveToNextAttribute();
Debug.Assert(moveTo);
_currentAttrIndex++;
if (_inlineSchemaParser == null)
{
_attributePSVI = _attributePSVINodes[_currentAttrIndex];
}
else
{
_attributePSVI = null;
}
_validationState = ValidatingReaderState.OnAttribute;
goto Found;
}
else if (_currentAttrIndex + 1 < _attributeCount)
{ //default attribute
int defaultIndex = ++_currentAttrIndex - _coreReaderAttributeCount;
_cachedNode = (ValidatingReaderNodeData)_defaultAttributes[defaultIndex];
_attributePSVI = _cachedNode.AttInfo;
_validationState = ValidatingReaderState.OnDefaultAttribute;
goto Found;
}
return false;
Found:
if (_validationState == ValidatingReaderState.OnReadBinaryContent)
{
_readBinaryHelper.Finish();
_validationState = _savedState;
}
return true;
}
public override void MoveToAttribute(int i)
{
if ((i < 0) || (i >= this.attributeCount))
{
throw new ArgumentOutOfRangeException("i");
}
this.currentAttrIndex = i;
this.cachedNode = this.attributeEvents[i];
}
// Moves to the next attribute.
public override bool MoveToNextAttribute() {
if (currentAttrIndex + 1 < coreReaderAttributeCount) {
bool moveTo = coreReader.MoveToNextAttribute();
Debug.Assert(moveTo);
currentAttrIndex++;
if (inlineSchemaParser == null) {
attributePSVI = attributePSVINodes[currentAttrIndex];
}
else {
attributePSVI = null;
}
validationState = ValidatingReaderState.OnAttribute;
goto Found;
}
else if (currentAttrIndex + 1 < attributeCount) { //default attribute
int defaultIndex = ++currentAttrIndex - coreReaderAttributeCount;
cachedNode = (ValidatingReaderNodeData)defaultAttributes[defaultIndex];
attributePSVI = cachedNode.AttInfo;
validationState = ValidatingReaderState.OnDefaultAttribute;
goto Found;
}
return false;
Found:
if (validationState == ValidatingReaderState.OnReadBinaryContent) {
readBinaryHelper.Finish();
validationState = savedState;
}
return true;
}
// Moves to the first attribute.
public override bool MoveToFirstAttribute() {
if (attributeCount == 0) {
return false;
}
currentAttrIndex = 0;
cachedNode = attributeEvents[0];
return true;
}
// Moves to the attribute with the specified LocalName and NamespaceURI
public override bool MoveToAttribute( string name, string ns ) {
ns = (ns == null) ? string.Empty : coreReaderNameTable.Get(ns);
name = coreReaderNameTable.Get(name);
ValidatingReaderNodeData attribute;
for ( int i = 0; i < attributeCount; i++ ) {
attribute = attributeEvents[i];
if ( Ref.Equal(attribute.LocalName, name) &&
Ref.Equal(attribute.Namespace, ns) ) {
currentAttrIndex = i;
cachedNode = attributeEvents[i];
return true;
}
}
return false;
}
internal void GetUnspecifiedDefaultAttributes(ArrayList defaultAttributes, bool createNodeData) {
currentState = ValidatorState.Attribute;
SchemaElementDecl currentElementDecl = context.ElementDecl;
if (currentElementDecl != null && currentElementDecl.HasDefaultAttribute) {
for (int i = 0; i < currentElementDecl.DefaultAttDefs.Count; ++i) {
SchemaAttDef attdef = (SchemaAttDef)currentElementDecl.DefaultAttDefs[i];
if (!attPresence.Contains(attdef.Name)) {
if (attdef.DefaultValueTyped == null) { //Invalid attribute default in the schema
continue;
}
//Check to see default attributes WILL be qualified if attributeFormDefault = qualified in schema
string attributeNS = nameTable.Add(attdef.Name.Namespace);
string defaultPrefix = string.Empty;
if (attributeNS.Length > 0) {
defaultPrefix = GetDefaultAttributePrefix(attributeNS);
if (defaultPrefix == null || defaultPrefix.Length == 0) {
SendValidationEvent(Res.Sch_DefaultAttributeNotApplied, new string[2] { attdef.Name.ToString(), QNameString(context.LocalName, context.Namespace)});
continue;
}
}
XmlSchemaDatatype datatype = attdef.Datatype;
if (createNodeData) {
ValidatingReaderNodeData attrData = new ValidatingReaderNodeData();
attrData.LocalName = nameTable.Add(attdef.Name.Name);
attrData.Namespace = attributeNS;
attrData.Prefix = nameTable.Add(defaultPrefix);
attrData.NodeType = XmlNodeType.Attribute;
//set PSVI properties
AttributePSVIInfo attrValidInfo = new AttributePSVIInfo();
XmlSchemaInfo attSchemaInfo = attrValidInfo.attributeSchemaInfo;
Debug.Assert(attSchemaInfo != null);
if (attdef.Datatype.Variety == XmlSchemaDatatypeVariety.Union) {
XsdSimpleValue simpleValue = attdef.DefaultValueTyped as XsdSimpleValue;
attSchemaInfo.MemberType = simpleValue.XmlType;
datatype = simpleValue.XmlType.Datatype;
attrValidInfo.typedAttributeValue = simpleValue.TypedValue;
}
else {
attrValidInfo.typedAttributeValue = attdef.DefaultValueTyped;
}
attSchemaInfo.IsDefault = true;
attSchemaInfo.Validity = XmlSchemaValidity.Valid;
attSchemaInfo.SchemaType = attdef.SchemaType;
attSchemaInfo.SchemaAttribute = attdef.SchemaAttribute;
attrData.RawValue = attSchemaInfo.XmlType.ValueConverter.ToString(attrValidInfo.typedAttributeValue);
attrData.AttInfo = attrValidInfo;
defaultAttributes.Add(attrData);
}
else {
defaultAttributes.Add(attdef.SchemaAttribute);
}
CheckTokenizedTypes(datatype, attdef.DefaultValueTyped, true);
if (HasIdentityConstraints) {
AttributeIdentityConstraints(attdef.Name.Name, attdef.Name.Namespace, attdef.DefaultValueTyped, attdef.DefaultValueRaw, datatype);
}
}
}
}
return;
}
// Reads the next node from the stream/TextReader.
public override bool Read() {
switch (cacheState) {
case CachingReaderState.Init:
cacheState = CachingReaderState.Record;
goto case CachingReaderState.Record;
case CachingReaderState.Record:
ValidatingReaderNodeData recordedNode = null;
if (coreReader.Read()) {
switch(coreReader.NodeType) {
case XmlNodeType.Element:
//Dont record element within the content of a union type since the main reader will break on this and the underlying coreReader will be positioned on this node
cacheState = CachingReaderState.ReaderClosed;
return false;
case XmlNodeType.EndElement:
recordedNode = AddContent(coreReader.NodeType);
recordedNode.SetItemData(coreReader.LocalName, coreReader.Prefix, coreReader.NamespaceURI, coreReader.Depth); //Only created for element node type
recordedNode.SetLineInfo(lineInfo);
break;
case XmlNodeType.Comment:
case XmlNodeType.ProcessingInstruction:
case XmlNodeType.Text:
case XmlNodeType.Whitespace:
case XmlNodeType.SignificantWhitespace:
recordedNode = AddContent(coreReader.NodeType);
recordedNode.SetItemData(coreReader.Value);
recordedNode.SetLineInfo(lineInfo);
recordedNode.Depth = coreReader.Depth;
break;
default:
break;
}
cachedNode = recordedNode;
return true;
}
else {
cacheState = CachingReaderState.ReaderClosed;
return false;
}
case CachingReaderState.Replay:
if (currentContentIndex >= contentIndex) { //When positioned on the last cached node, switch back as the underlying coreReader is still positioned on this node
cacheState = CachingReaderState.ReaderClosed;
cacheHandler(this);
if (coreReader.NodeType != XmlNodeType.Element || readAhead) { //Only when coreReader not positioned on Element node, read ahead, otherwise it is on the next element node already, since this was not cached
return coreReader.Read();
}
return true;
}
cachedNode = contentEvents[currentContentIndex];
if (currentContentIndex > 0) {
ClearAttributesInfo();
}
currentContentIndex++;
return true;
default:
return false;
}
}
internal void GetUnspecifiedDefaultAttributes(ArrayList defaultAttributes, bool createNodeData)
{
this.currentState = ValidatorState.Attribute;
SchemaElementDecl elementDecl = this.context.ElementDecl;
if ((elementDecl != null) && elementDecl.HasDefaultAttribute)
{
for (int i = 0; i < elementDecl.DefaultAttDefs.Count; i++)
{
SchemaAttDef def = (SchemaAttDef) elementDecl.DefaultAttDefs[i];
if (!this.attPresence.Contains(def.Name) && (def.DefaultValueTyped != null))
{
string attributeNS = this.nameTable.Add(def.Name.Namespace);
string array = string.Empty;
if (attributeNS.Length > 0)
{
array = this.GetDefaultAttributePrefix(attributeNS);
if ((array == null) || (array.Length == 0))
{
this.SendValidationEvent("Sch_DefaultAttributeNotApplied", new string[] { def.Name.ToString(), QNameString(this.context.LocalName, this.context.Namespace) });
continue;
}
}
XmlSchemaDatatype dtype = def.Datatype;
if (createNodeData)
{
ValidatingReaderNodeData data = new ValidatingReaderNodeData {
LocalName = this.nameTable.Add(def.Name.Name),
Namespace = attributeNS,
Prefix = this.nameTable.Add(array),
NodeType = XmlNodeType.Attribute
};
AttributePSVIInfo info = new AttributePSVIInfo();
XmlSchemaInfo attributeSchemaInfo = info.attributeSchemaInfo;
if (def.Datatype.Variety == XmlSchemaDatatypeVariety.Union)
{
XsdSimpleValue defaultValueTyped = def.DefaultValueTyped as XsdSimpleValue;
attributeSchemaInfo.MemberType = defaultValueTyped.XmlType;
dtype = defaultValueTyped.XmlType.Datatype;
info.typedAttributeValue = defaultValueTyped.TypedValue;
}
else
{
info.typedAttributeValue = def.DefaultValueTyped;
}
attributeSchemaInfo.IsDefault = true;
attributeSchemaInfo.Validity = XmlSchemaValidity.Valid;
attributeSchemaInfo.SchemaType = def.SchemaType;
attributeSchemaInfo.SchemaAttribute = def.SchemaAttribute;
data.RawValue = attributeSchemaInfo.XmlType.ValueConverter.ToString(info.typedAttributeValue);
data.AttInfo = info;
defaultAttributes.Add(data);
}
else
{
defaultAttributes.Add(def.SchemaAttribute);
}
this.CheckTokenizedTypes(dtype, def.DefaultValueTyped, true);
if (this.HasIdentityConstraints)
{
this.AttributeIdentityConstraints(def.Name.Name, def.Name.Namespace, def.DefaultValueTyped, def.DefaultValueRaw, dtype);
}
}
}
}
}
// Moves to the attribute with the specified index
public override void MoveToAttribute(int i) {
if (i < 0 || i >= attributeCount) {
throw new ArgumentOutOfRangeException("i");
}
currentAttrIndex = i;
if (i < coreReaderAttributeCount) { //reader attribute
coreReader.MoveToAttribute(i);
if (inlineSchemaParser == null) {
attributePSVI = attributePSVINodes[i];
}
else {
attributePSVI = null;
}
validationState = ValidatingReaderState.OnAttribute;
}
else { //default attribute
int defaultIndex = i - coreReaderAttributeCount;
cachedNode = (ValidatingReaderNodeData)defaultAttributes[defaultIndex];
attributePSVI = cachedNode.AttInfo;
validationState = ValidatingReaderState.OnDefaultAttribute;
}
if (validationState == ValidatingReaderState.OnReadBinaryContent) {
readBinaryHelper.Finish();
validationState = savedState;
}
}
// Moves to the attribute with the specified LocalName and NamespaceURI
public override bool MoveToAttribute(string name, string ns) {
//Check atomized local name and ns
name = coreReaderNameTable.Get(name);
ns = ns != null ? coreReaderNameTable.Get(ns) : string.Empty;
if (name == null || ns == null) { //Name or ns not found in the nameTable, then attribute is not found
return false;
}
if (coreReader.MoveToAttribute(name, ns)) {
validationState = ValidatingReaderState.OnAttribute;
if (inlineSchemaParser == null) {
attributePSVI = GetAttributePSVI(name, ns);
Debug.Assert(attributePSVI != null);
}
else { //Parsing inline schema, no PSVI for schema attributes
attributePSVI = null;
}
goto Found;
}
else { //Default attribute
ValidatingReaderNodeData defaultNode = GetDefaultAttribute(name, ns, true);
if (defaultNode != null) {
attributePSVI = defaultNode.AttInfo;
cachedNode = defaultNode;
validationState = ValidatingReaderState.OnDefaultAttribute;
goto Found;
}
}
return false;
Found:
if (validationState == ValidatingReaderState.OnReadBinaryContent) {
readBinaryHelper.Finish();
validationState = savedState;
}
return true;
}
// Moves to the attribute with the specified Name
public override bool MoveToAttribute(string name) {
if (coreReader.MoveToAttribute(name)) {
validationState = ValidatingReaderState.OnAttribute;
attributePSVI = GetAttributePSVI(name);
goto Found;
}
else if (attributeCount > 0) { //Default attribute
ValidatingReaderNodeData defaultNode = GetDefaultAttribute(name, true);
if (defaultNode != null) {
validationState = ValidatingReaderState.OnDefaultAttribute;
attributePSVI = defaultNode.AttInfo;
cachedNode = defaultNode;
goto Found;
}
}
return false;
Found:
if (validationState == ValidatingReaderState.OnReadBinaryContent) {
readBinaryHelper.Finish();
validationState = savedState;
}
return true;
}
// Parses the attribute value into one or more Text and/or EntityReference node types.
public override bool ReadAttributeValue() {
if (validationState == ValidatingReaderState.OnReadBinaryContent) {
readBinaryHelper.Finish();
validationState = savedState;
}
if (NodeType == XmlNodeType.Attribute) {
if (validationState == ValidatingReaderState.OnDefaultAttribute) {
cachedNode = CreateDummyTextNode(cachedNode.RawValue, cachedNode.Depth + 1);
validationState = ValidatingReaderState.OnReadAttributeValue;
return true;
}
return coreReader.ReadAttributeValue();
}
return false;
}
// Moves to the first attribute.
public override bool MoveToFirstAttribute()
{
if (_coreReader.MoveToFirstAttribute())
{
_currentAttrIndex = 0;
if (_inlineSchemaParser == null)
{
_attributePSVI = _attributePSVINodes[0];
}
else
{
_attributePSVI = null;
}
_validationState = ValidatingReaderState.OnAttribute;
goto Found;
}
else if (_defaultAttributes.Count > 0)
{ //check for default
_cachedNode = (ValidatingReaderNodeData)_defaultAttributes[0];
_attributePSVI = _cachedNode.AttInfo;
_currentAttrIndex = 0;
_validationState = ValidatingReaderState.OnDefaultAttribute;
goto Found;
}
return false;
Found:
if (_validationState == ValidatingReaderState.OnReadBinaryContent)
{
_readBinaryHelper.Finish();
_validationState = _savedState;
}
return true;
}
// Moves to the attribute with the specified index
public override void MoveToAttribute(int i)
{
if (i < 0 || i >= _attributeCount)
{
throw new ArgumentOutOfRangeException(nameof(i));
}
_currentAttrIndex = i;
if (i < _coreReaderAttributeCount)
{ //reader attribute
_coreReader.MoveToAttribute(i);
if (_inlineSchemaParser == null)
{
_attributePSVI = _attributePSVINodes[i];
}
else
{
_attributePSVI = null;
}
_validationState = ValidatingReaderState.OnAttribute;
}
else
{ //default attribute
int defaultIndex = i - _coreReaderAttributeCount;
_cachedNode = (ValidatingReaderNodeData)_defaultAttributes[defaultIndex];
_attributePSVI = _cachedNode.AttInfo;
_validationState = ValidatingReaderState.OnDefaultAttribute;
}
if (_validationState == ValidatingReaderState.OnReadBinaryContent)
{
_readBinaryHelper.Finish();
_validationState = _savedState;
}
}
private ValidatingReaderNodeData AddAttribute(int attIndex) {
Debug.Assert(attIndex <= attributeEvents.Length);
ValidatingReaderNodeData attInfo = attributeEvents[attIndex];
if (attInfo != null) {
attInfo.Clear(XmlNodeType.Attribute);
return attInfo;
}
if (attIndex >= attributeEvents.Length -1 ) { //reached capacity of array, Need to increase capacity to twice the initial
ValidatingReaderNodeData[] newAttributeEvents = new ValidatingReaderNodeData[attributeEvents.Length * 2];
Array.Copy(attributeEvents, 0, newAttributeEvents, 0, attributeEvents.Length);
attributeEvents = newAttributeEvents;
}
attInfo = attributeEvents[attIndex];
if (attInfo == null) {
attInfo = new ValidatingReaderNodeData(XmlNodeType.Attribute);
attributeEvents[attIndex] = attInfo;
}
return attInfo;
}
// Moves to the attribute with the specified Name.
public override bool MoveToAttribute( string name ) {
int i;
if (name.IndexOf( ':' ) == -1) {
i = GetAttributeIndexWithoutPrefix( name );
}
else {
i = GetAttributeIndexWithPrefix( name );
}
if ( i >= 0 ) {
currentAttrIndex = i;
cachedNode = attributeEvents[i];
return true;
}
else {
return false;
}
}
private ValidatingReaderNodeData CreateDummyTextNode(string attributeValue, int depth) {
if (textNode == null) {
textNode = new ValidatingReaderNodeData(XmlNodeType.Text);
}
textNode.Depth = depth;
textNode.RawValue = attributeValue;
return textNode;
}
// Moves to the attribute with the specified index.
public override void MoveToAttribute(int i) {
if ( i < 0 || i >= attributeCount ) {
throw new ArgumentOutOfRangeException( "i" );
}
currentAttrIndex = i;
cachedNode = attributeEvents[i];
}
public override bool MoveToAttribute(string name)
{
int attributeIndexWithoutPrefix;
if (name.IndexOf(':') == -1)
{
attributeIndexWithoutPrefix = this.GetAttributeIndexWithoutPrefix(name);
}
else
{
attributeIndexWithoutPrefix = this.GetAttributeIndexWithPrefix(name);
}
if (attributeIndexWithoutPrefix >= 0)
{
this.currentAttrIndex = attributeIndexWithoutPrefix;
this.cachedNode = this.attributeEvents[attributeIndexWithoutPrefix];
return true;
}
return false;
}
// Moves to the next attribute.
public override bool MoveToNextAttribute() {
if (currentAttrIndex + 1 < attributeCount) {
cachedNode = attributeEvents[++currentAttrIndex];
return true;
}
return false;
}
public override bool ReadAttributeValue()
{
if (this.cachedNode.NodeType != XmlNodeType.Attribute)
{
return false;
}
this.cachedNode = this.CreateDummyTextNode(this.cachedNode.RawValue, this.cachedNode.Depth + 1);
return true;
}
// Parses the attribute value into one or more Text and/or EntityReference node types.
public override bool ReadAttributeValue() {
Debug.Assert(cacheState == CachingReaderState.Replay);
if (cachedNode.NodeType != XmlNodeType.Attribute) {
return false;
}
cachedNode = CreateDummyTextNode(cachedNode.RawValue, cachedNode.Depth + 1);
return true;
}
public override bool Read()
{
switch (this.cacheState)
{
case CachingReaderState.Init:
this.cacheState = CachingReaderState.Record;
break;
case CachingReaderState.Record:
break;
case CachingReaderState.Replay:
if (this.currentContentIndex < this.contentIndex)
{
this.cachedNode = this.contentEvents[this.currentContentIndex];
if (this.currentContentIndex > 0)
{
this.ClearAttributesInfo();
}
this.currentContentIndex++;
return true;
}
this.cacheState = CachingReaderState.ReaderClosed;
this.cacheHandler(this);
return (((this.coreReader.NodeType == XmlNodeType.Element) && !this.readAhead) || this.coreReader.Read());
default:
return false;
}
ValidatingReaderNodeData data = null;
if (!this.coreReader.Read())
{
this.cacheState = CachingReaderState.ReaderClosed;
return false;
}
switch (this.coreReader.NodeType)
{
case XmlNodeType.Element:
this.cacheState = CachingReaderState.ReaderClosed;
return false;
case XmlNodeType.Text:
case XmlNodeType.CDATA:
case XmlNodeType.ProcessingInstruction:
case XmlNodeType.Comment:
case XmlNodeType.Whitespace:
case XmlNodeType.SignificantWhitespace:
data = this.AddContent(this.coreReader.NodeType);
data.SetItemData(this.coreReader.Value);
data.SetLineInfo(this.lineInfo);
data.Depth = this.coreReader.Depth;
break;
case XmlNodeType.EndElement:
data = this.AddContent(this.coreReader.NodeType);
data.SetItemData(this.coreReader.LocalName, this.coreReader.Prefix, this.coreReader.NamespaceURI, this.coreReader.Depth);
data.SetLineInfo(this.lineInfo);
break;
}
this.cachedNode = data;
return true;
}
private ValidatingReaderNodeData AddContent(XmlNodeType nodeType) {
Debug.Assert(contentIndex <= contentEvents.Length);
ValidatingReaderNodeData contentInfo = contentEvents[contentIndex];
if (contentInfo != null) {
contentInfo.Clear(nodeType);
contentIndex++;
return contentInfo;
}
if (contentIndex >= contentEvents.Length -1 ) { //reached capacity of array, Need to increase capacity to twice the initial
ValidatingReaderNodeData[] newContentEvents = new ValidatingReaderNodeData[contentEvents.Length * 2];
Array.Copy(contentEvents, 0, newContentEvents, 0, contentEvents.Length);
contentEvents = newContentEvents;
}
contentInfo = contentEvents[contentIndex];
if (contentInfo == null) {
contentInfo = new ValidatingReaderNodeData(nodeType);
contentEvents[contentIndex] = contentInfo;
}
contentIndex++;
return contentInfo;
}
public override bool MoveToNextAttribute()
{
if ((this.currentAttrIndex + 1) < this.attributeCount)
{
this.cachedNode = this.attributeEvents[++this.currentAttrIndex];
return true;
}
return false;
}
// Moves to the first attribute.
public override bool MoveToFirstAttribute() {
if (coreReader.MoveToFirstAttribute()) {
currentAttrIndex = 0;
if (inlineSchemaParser == null) {
attributePSVI = attributePSVINodes[0];
}
else {
attributePSVI = null;
}
validationState = ValidatingReaderState.OnAttribute;
goto Found;
}
else if (defaultAttributes.Count > 0) { //check for default
cachedNode = (ValidatingReaderNodeData)defaultAttributes[0];
attributePSVI = cachedNode.AttInfo;
currentAttrIndex = 0;
validationState = ValidatingReaderState.OnDefaultAttribute;
goto Found;
}
return false;
Found:
if (validationState == ValidatingReaderState.OnReadBinaryContent) {
readBinaryHelper.Finish();
validationState = savedState;
}
return true;
}
public override bool MoveToAttribute(string name, string ns)
{
ns = (ns == null) ? string.Empty : this.coreReaderNameTable.Get(ns);
name = this.coreReaderNameTable.Get(name);
for (int i = 0; i < this.attributeCount; i++)
{
ValidatingReaderNodeData data = this.attributeEvents[i];
if (Ref.Equal(data.LocalName, name) && Ref.Equal(data.Namespace, ns))
{
this.currentAttrIndex = i;
this.cachedNode = this.attributeEvents[i];
return true;
}
}
return false;
}
