public XmlParserInput
(TextReader reader,
XmlNameTable nameTable,
EOFHandler eof)
: this(reader, nameTable, eof, null)
{
}
public Preprocessor(XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventHandler, XmlSchemaCompilationSettings compilationSettings)
: base(nameTable, schemaNames, eventHandler, compilationSettings)
{
_referenceNamespaces = new Hashtable();
_processedExternals = new Hashtable();
_lockList = new SortedList();
}
public XmlParserInput
(TextReader reader,
XmlNameTable nameTable,
ErrorHandler error)
: this(reader, nameTable, null, error)
{
}
/// <summary>
/// Initializes a new instance of the XmlReaderSettings class.
/// </summary>
public XmlReaderSettings()
{
NameTable = null;
IgnoreWhitespace = false;
IgnoreProcessingInstructions = false;
IgnoreComments = false;
}
internal XPathDocument() {
this.space = XmlSpace.Default;
this.root = new XPathRoot();
this.root.topNamespace = new XPathNamespace( "xml", "http://www.w3.org/XML/1998/namespace", ++ documentIndex );
this.nt = new NameTable();
this.baseURI = string.Empty;
}
// Constructor.
public NameCache(XmlNameTable nt) : base(128) // avoid expanding of hashtable
{
nameTable = nt;
// only NameTable is guaranted to use String.Empty
emptyString = nt.Add(String.Empty);
}
/// <summary>
/// Create a new empty document. All names should be atomized using "nameTable".
/// </summary>
internal XPathDocument(XmlNameTable nameTable)
{
if (nameTable == null)
throw new ArgumentNullException(nameof(nameTable));
_nameTable = nameTable;
}
internal XNodeReader(XNode node, XmlNameTable nameTable, ReaderOptions options)
{
_source = node;
_root = node;
_nameTable = nameTable != null ? nameTable : CreateNameTable();
_omitDuplicateNamespaces = (options & ReaderOptions.OmitDuplicateNamespaces) != 0 ? true : false;
}
: this(nameTable, schemaNames, eventHandler, new XmlSchemaCompilationSettings()) {} //Use the default for XmlSchemaCollection
public BaseProcessor(XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventHandler, XmlSchemaCompilationSettings compilationSettings) {
Debug.Assert(nameTable != null);
this.nameTable = nameTable;
this.schemaNames = schemaNames;
this.eventHandler = eventHandler;
this.compilationSettings = compilationSettings;
NsXml = nameTable.Add(XmlReservedNs.NsXml);
}
public XPathNavigator(XObject obj)
{
_obj = obj;
_nameTable = new NameTable();
_nameTable.Add(string.Empty);
_nameTable.Add("http://www.w3.org/2000/xmlns/");
_nameTable.Add("http://www.w3.org/XML/1998/namespace");
}
public XmlSchemaSet (XmlNameTable nameTable)
{
if (nameTable == null)
throw new ArgumentNullException ("nameTable");
this.nameTable = nameTable;
schemas = new ArrayList ();
CompilationId = Guid.NewGuid ();
}
public Parser(SchemaType schemaType, XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventHandler) {
this.schemaType = schemaType;
this.nameTable = nameTable;
this.schemaNames = schemaNames;
this.eventHandler = eventHandler;
this.xmlResolver = new XmlUrlResolver();
processMarkup = true;
dummyDocument = new XmlDocument();
}
public Parser(SchemaType schemaType, XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventHandler) {
this.schemaType = schemaType;
this.nameTable = nameTable;
this.schemaNames = schemaNames;
this.eventHandler = eventHandler;
this.xmlResolver = System.Xml.XmlConfiguration.XmlReaderSection.CreateDefaultResolver();
processMarkup = true;
dummyDocument = new XmlDocument();
}
public BaseValidator(XmlValidatingReaderImpl reader, XmlSchemaCollection schemaCollection, ValidationEventHandler eventHandler) {
Debug.Assert(schemaCollection == null || schemaCollection.NameTable == reader.NameTable);
this.reader = reader;
this.schemaCollection = schemaCollection;
this.eventHandler = eventHandler;
nameTable = reader.NameTable;
positionInfo = PositionInfo.GetPositionInfo(reader);
elementName = new XmlQualifiedName();
}
public Parser(SchemaType schemaType, XmlNameTable nameTable, SchemaNames schemaNames, ValidationEventHandler eventHandler)
{
_schemaType = schemaType;
_nameTable = nameTable;
_schemaNames = schemaNames;
_eventHandler = eventHandler;
_xmlResolver = null;
_processMarkup = true;
_dummyDocument = new XmlDocument();
}
public BaseValidator(BaseValidator other) {
reader = other.reader;
schemaCollection = other.schemaCollection;
eventHandler = other.eventHandler;
nameTable = other.nameTable;
schemaNames = other.schemaNames;
positionInfo = other.positionInfo;
xmlResolver = other.xmlResolver;
baseUri = other.baseUri;
elementName = other.elementName;
}
// Constructor.
protected XmlParserInputBase
(XmlNameTable nameTable,
EOFHandler eof,
ErrorHandler error)
: base(error)
{
this.nameTable = nameTable;
this.eofHandler = eof;
this.currChar = '\0';
this.peekChar = '\0';
this.logger = new LogManager();
}
/// <include file='doc\XmlSchemaCollection.uex' path='docs/doc[@for="XmlSchemaCollection.XmlSchemaCollection1"]/*' />
/// <devdoc>
/// <para>Construct a new empty schema collection with associated XmlNameTable.
/// The XmlNameTable is used when loading schemas</para>
/// </devdoc>
public XmlSchemaCollection(XmlNameTable nametable) {
if (nametable == null) {
throw new ArgumentNullException("nametable");
}
nameTable = nametable;
collection = Hashtable.Synchronized(new Hashtable());
xmlResolver = new XmlUrlResolver();
isThreadSafe = true;
if (isThreadSafe) {
wLock = new ReaderWriterLock();
}
}
/// <include file='doc\XmlSchemaCollection.uex' path='docs/doc[@for="XmlSchemaCollection.XmlSchemaCollection1"]/*' />
/// <devdoc>
/// <para>Construct a new empty schema collection with associated XmlNameTable.
/// The XmlNameTable is used when loading schemas</para>
/// </devdoc>
public XmlSchemaCollection(XmlNameTable nametable) {
if (nametable == null) {
throw new ArgumentNullException("nametable");
}
nameTable = nametable;
collection = Hashtable.Synchronized(new Hashtable());
xmlResolver = System.Xml.XmlConfiguration.XmlReaderSection.CreateDefaultResolver();
isThreadSafe = true;
if (isThreadSafe) {
wLock = new ReaderWriterLock();
}
}
public XmlParserInput
(TextReader reader,
XmlNameTable nameTable,
EOFHandler eof,
ErrorHandler error)
: base(nameTable, eof, error)
{
this.lineNumber = 1;
this.linePosition = 1;
this.bufferPos = 0;
this.bufferLen = 0;
this.buffer = new char[BUFSIZE];
this.reader = reader;
this.extraPeekChar = '\0';
}
/// <include file='doc\XmlSchemaCollection.uex' path='docs/doc[@for="XmlSchemaCollection.XmlSchemaCollection1"]/*' />
/// <devdoc>
/// <para>Construct a new empty schema collection with associated XmlNameTable.
/// The XmlNameTable is used when loading schemas</para>
/// </devdoc>
public XmlSchemaCollection(XmlNameTable nametable)
{
if (nametable == null)
{
throw new ArgumentNullException(nameof(nametable));
}
_nameTable = nametable;
_collection = Hashtable.Synchronized(new Hashtable());
_xmlResolver = System.Xml.XmlConfiguration.XmlReaderSection.CreateDefaultResolver();
_isThreadSafe = true;
if (_isThreadSafe)
{
_wLock = new object();
}
}
/// <include file='doc\XmlSchemaCollection.uex' path='docs/doc[@for="XmlSchemaCollection.XmlSchemaCollection1"]/*' />
/// <devdoc>
/// <para>Construct a new empty schema collection with associated XmlNameTable.
/// The XmlNameTable is used when loading schemas</para>
/// </devdoc>
public XmlSchemaCollection(XmlNameTable nametable)
{
if (nametable == null)
{
throw new ArgumentNullException(nameof(nametable));
}
_nameTable = nametable;
_collection = Hashtable.Synchronized(new Hashtable());
_xmlResolver = null;
_isThreadSafe = true;
if (_isThreadSafe)
{
_wLock = new object();
}
}
// Constructor.
public XmlDTDParserInput
(XmlParserInput input,
XmlNameTable nameTable)
: base(nameTable, null, input.ErrorHandler)
{
this.input = input;
this.peValue = null;
this.pePosition = -1;
this.scanForPE = true;
this.parameterEntities = new PEManager
(nameTable, input.ErrorHandler);
#if !ECMA_COMPAT
this.valid = true;
this.started = false;
#endif
base.logger = null;
}
internal Validator(XmlNameTable nameTable, SchemaNames schemaNames, XmlValidatingReader reader) {
this.nameTable = nameTable;
this.schemaNames = schemaNames;
this.reader = reader;
positionInfo = PositionInfo.GetPositionInfo(reader);
nsManager = reader.NamespaceManager;
if (nsManager == null) {
nsManager = new XmlNamespaceManager(nameTable);
isProcessContents = true;
}
SchemaInfo = new SchemaInfo(schemaNames);
validationStack = new HWStack(STACK_INCREMENT);
textValue = new StringBuilder();
this.name = XmlQualifiedName.Empty;
attPresence = new Hashtable();
context = null;
attnDef = null;
}
internal abstract Exception TryParseValue(object value, XmlNameTable nameTable, IXmlNamespaceResolver namespaceResolver, out object typedValue);
public XNodeNavigator(XNodeNavigator other)
{
_source = other._source;
_parent = other._parent;
_nameTable = other._nameTable;
}
/// <summary>
/// Initializes a new instance of the <see cref="MacroNavigator"/> class with a macro node,
/// a name table and a state.
/// </summary>
/// <param name="macro">The macro node.</param>
/// <param name="nameTable">The name table.</param>
/// <param name="state">The state.</param>
/// <remarks>Privately used for cloning a navigator.</remarks>
private MacroNavigator(MacroRoot macro, XmlNameTable nameTable, State state)
{
_macro = macro;
_nameTable = nameTable;
_state = state;
}
public IRecordLoader CreateRecordLoader(XmlNameTable nameTable)
{
return(new RecordLoader <GraphicsArrayData>(nameTable, this.Table, rowId => this.Register(rowId)));
}
/// <summary>
/// Creates <c>XPointerReader</c> instance with given uri, stream, nametable and xpointer.
/// </summary>
public XPointerReader(string uri, Stream stream, XmlNameTable nt, string xpointer)
: this(new XmlBaseAwareXmlReader(uri, stream, nt), xpointer)
{
}
internal abstract XmlSchemaDatatype DeriveByRestriction(XmlSchemaObjectCollection facets, XmlNameTable nameTable, XmlSchemaType schemaType);
//-----------------------------------------------
// Constructors
//-----------------------------------------------
/// <summary>
/// This constructor is internal so that external users cannot construct it (and therefore we do not have to test it separately).
/// </summary>
internal XmlQueryRuntime(XmlILCommand cmd, object defaultDataSource, XmlResolver dataSources, XsltArgumentList argList, XmlSequenceWriter seqWrt)
{
Debug.Assert(cmd != null, "Command object must be non-null");
string[] names = cmd.Names;
Int32Pair[] filters = cmd.Filters;
WhitespaceRuleLookup wsRules;
int i;
this.cmd = cmd;
// Early-Bound Library Objects
wsRules = (cmd.WhitespaceRules.Count != 0) ? new WhitespaceRuleLookup(cmd.WhitespaceRules) : null;
this.ctxt = new XmlQueryContext(this, defaultDataSource, dataSources, argList, wsRules);
this.xsltLib = null;
this.earlyInfo = cmd.EarlyBound;
this.earlyObjects = (this.earlyInfo != null) ? new object[earlyInfo.Length] : null;
// Global variables and parameters
this.globalNames = cmd.GlobalNames;
this.globalValues = (this.globalNames != null) ? new object[this.globalNames.Length] : null;
// Names
this.nameTableQuery = this.ctxt.QueryNameTable;
this.atomizedNames = null;
if (names != null)
{
// Atomize all names in "nameTableQuery". Use names from the default data source's
// name table when possible.
XmlNameTable nameTableDefault = ctxt.DefaultNameTable;
this.atomizedNames = new string[names.Length];
if (nameTableDefault != this.nameTableQuery && nameTableDefault != null)
{
// Ensure that atomized names from the default data source are added to the
// name table used in this query
for (i = 0; i < names.Length; i++)
{
string name = nameTableDefault.Get(names[i]);
this.atomizedNames[i] = this.nameTableQuery.Add(name ?? names[i]);
}
}
else
{
// Enter names into nametable used in this query
for (i = 0; i < names.Length; i++)
{
this.atomizedNames[i] = this.nameTableQuery.Add(names[i]);
}
}
}
// Name filters
this.filters = null;
if (filters != null)
{
// Construct name filters. Each pair of integers in the filters[] array specifies the
// (localName, namespaceUri) of the NameFilter to be created.
this.filters = new XmlNavigatorFilter[filters.Length];
for (i = 0; i < filters.Length; i++)
{
this.filters[i] = XmlNavNameFilter.Create(this.atomizedNames[filters[i].Left], this.atomizedNames[filters[i].Right]);
}
}
// Prefix maping lists
this.prefixMappingsList = cmd.PrefixMappingsList;
// Xml types
this.types = cmd.Types;
// Xml collations
this.collations = cmd.Collations;
// Document ordering
this.docOrderCmp = new DocumentOrderComparer();
// Indexes
this.indexes = null;
// Output construction
this.stkOutput = new Stack <XmlQueryOutput>(16);
this.output = new XmlQueryOutput(this, seqWrt);
}
internal override ValueType ParseValueType(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr)
{
return(new StringArrayValueType(this.GetValidatedArray(s, nameTable)));
}
private object ParseFacetValue(XmlSchemaDatatype datatype, XmlSchemaFacet facet, string code, IXmlNamespaceResolver nsmgr, XmlNameTable nameTable) {
object typedValue;
Exception ex = datatype.TryParseValue(facet.Value, nameTable, nsmgr, out typedValue);
if (ex == null) {
return typedValue;
}
else {
throw new XmlSchemaException(code, new string[] {ex.Message} , ex, facet.SourceUri, facet.LineNumber, facet.LinePosition, facet);
}
}
public abstract Object ParseValue(String s, XmlNameTable nameTable, XmlNamespaceManager nsmgr);
public XmlTextReader(string url, System.IO.TextReader input, XmlNameTable nt)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="SerializableXmlDocument"/> class.
/// </summary>
/// <param name="nt">
/// The XML name table.
/// </param>
public SerializableXmlDocument(XmlNameTable nt)
: base(nt)
{
}
public static void CheckDefaultValue(
string value,
SchemaAttDef attdef,
SchemaInfo sinfo,
XmlNamespaceManager nsManager,
XmlNameTable NameTable,
object sender,
ValidationEventHandler eventhandler,
string baseUri,
int lineNo,
int linePos
)
{
try {
XmlSchemaDatatype dtype = attdef.Datatype;
if (dtype == null)
{
return; // no reason to check
}
if (dtype.TokenizedType != XmlTokenizedType.CDATA)
{
value = value.Trim();
}
if (value.Length == 0)
{
return; // don't need to check
}
object typedValue = dtype.ParseValue(value, NameTable, nsManager);
// Check special types
XmlTokenizedType ttype = dtype.TokenizedType;
if (ttype == XmlTokenizedType.ENTITY)
{
if (dtype.Variety == XmlSchemaDatatypeVariety.List)
{
string[] ss = (string[])typedValue;
for (int i = 0; i < ss.Length; ++i)
{
ProcessEntity(sinfo, ss[i], sender, eventhandler, baseUri, lineNo, linePos);
}
}
else
{
ProcessEntity(sinfo, (string)typedValue, sender, eventhandler, baseUri, lineNo, linePos);
}
}
else if (ttype == XmlTokenizedType.ENUMERATION)
{
if (!attdef.CheckEnumeration(typedValue))
{
XmlSchemaException e = new XmlSchemaException(Res.Sch_EnumerationValue, typedValue.ToString(), baseUri, lineNo, linePos);
if (eventhandler != null)
{
eventhandler(sender, new ValidationEventArgs(e));
}
else
{
throw e;
}
}
}
attdef.DefaultValueTyped = typedValue;
}
#if DEBUG
catch (XmlSchemaException ex) {
Debug.WriteLineIf(DiagnosticsSwitches.XmlSchema.TraceError, ex.Message);
#else
catch {
#endif
XmlSchemaException e = new XmlSchemaException(Res.Sch_AttributeDefaultDataType, attdef.Name.ToString(), baseUri, lineNo, linePos);
if (eventhandler != null)
{
eventhandler(sender, new ValidationEventArgs(e));
}
else
{
throw e;
}
}
}
public XNodeNavigator(XNode node, XmlNameTable?nameTable)
{
_source = node;
_nameTable = nameTable != null ? nameTable : CreateNameTable();
}
internal abstract object ParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr, bool createAtomicValue);
// Used to read data with known schema
public XmlToDatasetMap(XmlNameTable nameTable, DataTable dataTable)
{
Debug.Assert(dataTable != null, "DataTable can't be null");
Debug.Assert(nameTable != null, "NameTable can't be null");
BuildIdentityMap(nameTable, dataTable);
}
public abstract object ParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr);
public void Reset(XmlName name, XmlNameTable nameTable)
{
LocalName = nameTable.Add(name.LocalName);
NamespaceUri = name.NamespaceUri != null?nameTable.Add(name.NamespaceUri) : null;
}
internal override ValueType ParseValueType(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr)
{
return(new StringValueType(this.ParseValue(s, nameTable, nsmgr) as string));
}
/// <summary>
/// pass all standard construction to base class
/// </summary>
public MathMLReader(string url, XmlNameTable nt) : base(url, nt)
{
}
public XNodeNavigator(XNode node, XmlNameTable nameTable)
{
this.source = node;
this.nameTable = nameTable != null ? nameTable : CreateNameTable();
}
public Document(
XmlNameTable nameTable)
: base(nameTable)
{
eventTarget = new EventTarget(this);
}
// Used to infer schema
public XmlToDatasetMap(DataSet dataSet, XmlNameTable nameTable)
{
Debug.Assert(dataSet != null, "DataSet can't be null");
Debug.Assert(nameTable != null, "NameTable can't be null");
BuildIdentityMap(dataSet, nameTable);
}
internal string Normalize(string s, XmlNameTable nt, XmlNamespaceManager nsmgr)
{
return(this.Content.Normalize(s, nt, nsmgr));
}
public IRecordLoader CreateRecordLoader(XmlNameTable nameTable)
{
return(new RecordLoader <ConstantData>(nameTable, this.Table, rowId => this.Register(rowId)));
}
internal override ValueType ParseValueType(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr)
{
return(XmlConvert.ToBoolean(base.Normalize(s)));
}
public XNodeNavigator(XNodeNavigator other)
{
source = other.source;
parent = other.parent;
nameTable = other.nameTable;
}
public override object ParseValue(string s, XmlNameTable nameTable, IXmlNamespaceResolver nsmgr)
{
return(this.ParseValueType(s, nameTable, nsmgr));
}
#pragma warning disable 618
internal bool CompileSchema(XmlSchemaCollection?xsc, XmlResolver?resolver, SchemaInfo schemaInfo, string?ns, ValidationEventHandler?validationEventHandler, XmlNameTable nameTable, bool CompileContentModel)
{
//Need to lock here to prevent multi-threading problems when same schema is added to set and compiled
lock (this)
{
//Preprocessing
SchemaCollectionPreprocessor prep = new SchemaCollectionPreprocessor(nameTable, null, validationEventHandler);
prep.XmlResolver = resolver;
if (!prep.Execute(this, ns, true, xsc))
{
return(false);
}
//Compilation
SchemaCollectionCompiler compiler = new SchemaCollectionCompiler(nameTable, validationEventHandler);
_isCompiled = compiler.Execute(this, schemaInfo, CompileContentModel);
this.SetIsCompiled(_isCompiled);
return(_isCompiled);
}
}
// This one is used while reading data with preloaded schema
private void BuildIdentityMap(XmlNameTable nameTable, DataSet dataSet)
{
_tableSchemaMap = new XmlNodeIdHashtable(dataSet.Tables.Count);
// This hash table contains
// tables schemas as TableSchemaInfo objects
// These objects holds reference to the table.
// Hash tables with columns schema maps
// and child tables schema maps
string dsNamespace = nameTable.Get(dataSet.Namespace); // Attept to look up DataSet namespace
// in the name table
if (dsNamespace == null)
{ // Found ?
dsNamespace = nameTable.Add(dataSet.Namespace); // Nope. Add it
}
dataSet._namespaceURI = dsNamespace; // Set a DataSet namespace URI
foreach (DataTable t in dataSet.Tables)
{ // For each table
TableSchemaInfo tableSchemaInfo = AddTableSchema(nameTable, t);
// Add table schema info to hash table
if (tableSchemaInfo != null)
{
foreach (DataColumn c in t.Columns)
{ // Add column schema map
// don't include auto-generated PK, FK and any hidden columns to be part of mapping
if (IsMappedColumn(c))
{ // If mapped column
AddColumnSchema(nameTable, c, tableSchemaInfo.ColumnsSchemaMap);
} // Add it to the map
}
// Add child nested tables to the schema
foreach (DataRelation r in t.ChildRelations)
{ // Do we have a child tables ?
if (r.Nested)
{ // Is it nested?
// don't include non nested tables
// Handle namespaces and names as usuall
string _tableLocalName = XmlConvert.EncodeLocalName(r.ChildTable.TableName);
string tableLocalName = nameTable.Get(_tableLocalName);
if (tableLocalName == null)
{
tableLocalName = nameTable.Add(_tableLocalName);
}
string tableNamespace = nameTable.Get(r.ChildTable.Namespace);
if (tableNamespace == null)
{
tableNamespace = nameTable.Add(r.ChildTable.Namespace);
}
XmlNodeIdentety idTable = new XmlNodeIdentety(tableLocalName, tableNamespace);
tableSchemaInfo.ColumnsSchemaMap[idTable] = r.ChildTable;
}
}
}
}
}
public XmlTextReader(string url, XmlNameTable nt)
{
}
//-----------------------------------------------
// Constructors
//-----------------------------------------------
/// <summary>
/// This constructor is internal so that external users cannot construct it (and therefore we do not have to test it separately).
/// </summary>
internal XmlQueryRuntime(XmlQueryStaticData data, object defaultDataSource, XmlResolver dataSources, XsltArgumentList argList, XmlSequenceWriter seqWrt)
{
Debug.Assert(data != null);
string[] names = data.Names;
Int32Pair[] filters = data.Filters;
WhitespaceRuleLookup wsRules;
int i;
// Early-Bound Library Objects
wsRules = (data.WhitespaceRules != null && data.WhitespaceRules.Count != 0) ? new WhitespaceRuleLookup(data.WhitespaceRules) : null;
_ctxt = new XmlQueryContext(this, defaultDataSource, dataSources, argList, wsRules);
_xsltLib = null;
_earlyInfo = data.EarlyBound;
_earlyObjects = (_earlyInfo != null) ? new object[_earlyInfo.Length] : null;
// Global variables and parameters
_globalNames = data.GlobalNames;
_globalValues = (_globalNames != null) ? new object[_globalNames.Length] : null;
// Names
_nameTableQuery = _ctxt.QueryNameTable;
_atomizedNames = null;
if (names != null)
{
// Atomize all names in "nameTableQuery". Use names from the default data source's
// name table when possible.
XmlNameTable nameTableDefault = _ctxt.DefaultNameTable;
_atomizedNames = new string[names.Length];
if (nameTableDefault != _nameTableQuery && nameTableDefault != null)
{
// Ensure that atomized names from the default data source are added to the
// name table used in this query
for (i = 0; i < names.Length; i++)
{
string name = nameTableDefault.Get(names[i]);
_atomizedNames[i] = _nameTableQuery.Add(name ?? names[i]);
}
}
else
{
// Enter names into nametable used in this query
for (i = 0; i < names.Length; i++)
{
_atomizedNames[i] = _nameTableQuery.Add(names[i]);
}
}
}
// Name filters
_filters = null;
if (filters != null)
{
// Construct name filters. Each pair of integers in the filters[] array specifies the
// (localName, namespaceUri) of the NameFilter to be created.
_filters = new XmlNavigatorFilter[filters.Length];
for (i = 0; i < filters.Length; i++)
{
_filters[i] = XmlNavNameFilter.Create(_atomizedNames[filters[i].Left], _atomizedNames[filters[i].Right]);
}
}
// Prefix maping lists
_prefixMappingsList = data.PrefixMappingsList;
// Xml types
_types = data.Types;
// Xml collations
_collations = data.Collations;
// Document ordering
_docOrderCmp = new DocumentOrderComparer();
// Indexes
_indexes = null;
// Output construction
_stkOutput = new Stack <XmlQueryOutput>(16);
_output = new XmlQueryOutput(this, seqWrt);
}
internal void CompileEnumerationFacet(XmlSchemaFacet facet, IXmlNamespaceResolver nsmgr, XmlNameTable nameTable) {
CheckProhibitedFlag(facet, RestrictionFlags.Enumeration, Res.Sch_EnumerationFacetProhibited);
if (derivedRestriction.Enumeration == null) {
derivedRestriction.Enumeration = new ArrayList();
}
derivedRestriction.Enumeration.Add(ParseFacetValue(datatype, facet, Res.Sch_EnumerationFacetInvalid, nsmgr, nameTable));
SetFlag(facet, RestrictionFlags.Enumeration);
}
public XmlDocumentExtender(XmlNameTable nt)
: base(new XmlImplementation(nt))
{
}
//Compile-time Facet Checking
internal virtual RestrictionFacets ConstructRestriction(DatatypeImplementation datatype, XmlSchemaObjectCollection facets, XmlNameTable nameTable) {
//Datatype is the type on which this method is called
RestrictionFacets derivedRestriction = new RestrictionFacets();
FacetsCompiler facetCompiler = new FacetsCompiler(datatype, derivedRestriction);
for (int i = 0; i < facets.Count; ++i) {
XmlSchemaFacet facet = (XmlSchemaFacet)facets[i];
if (facet.Value == null) {
throw new XmlSchemaException(Res.Sch_InvalidFacet, facet);
}
IXmlNamespaceResolver nsmgr = new SchemaNamespaceManager(facet);
switch(facet.FacetType) {
case FacetType.Length:
facetCompiler.CompileLengthFacet(facet);
break;
case FacetType.MinLength:
facetCompiler.CompileMinLengthFacet(facet);
break;
case FacetType.MaxLength:
facetCompiler.CompileMaxLengthFacet(facet);
break;
case FacetType.Pattern:
facetCompiler.CompilePatternFacet(facet as XmlSchemaPatternFacet);
break;
case FacetType.Enumeration:
facetCompiler.CompileEnumerationFacet(facet, nsmgr, nameTable);
break;
case FacetType.Whitespace:
facetCompiler.CompileWhitespaceFacet(facet);
break;
case FacetType.MinInclusive:
facetCompiler.CompileMinInclusiveFacet(facet);
break;
case FacetType.MinExclusive:
facetCompiler.CompileMinExclusiveFacet(facet);
break;
case FacetType.MaxInclusive:
facetCompiler.CompileMaxInclusiveFacet(facet);
break;
case FacetType.MaxExclusive:
facetCompiler.CompileMaxExclusiveFacet(facet);
break;
case FacetType.TotalDigits:
facetCompiler.CompileTotalDigitsFacet(facet);
break;
case FacetType.FractionDigits:
facetCompiler.CompileFractionDigitsFacet(facet);
break;
default:
throw new XmlSchemaException(Res.Sch_UnknownFacet, facet);
}
}
facetCompiler.FinishFacetCompile();
facetCompiler.CompileFacetCombinations();
return derivedRestriction;
}
public override object ParseValue(string value, XmlNameTable nt, IXmlNamespaceResolver nsmgr)
{
return(this.GetValidatedArray(value, nt));
}
