internal static CodeExpression CreateGetBuiltInSimpleType(XmlTypeCode typeCode) {
return CodeDomHelper.CreateMethodCall(
new CodeTypeReferenceExpression("XmlSchemaType"),
Constants.GetBuiltInSimpleType,
CodeDomHelper.CreateFieldReference(Constants.XmlTypeCode, typeCode.ToString()));
}
private static bool? IsDataTypeAttributeAllowed(XmlTypeCode typeCode, GeneratorConfiguration configuration)
{
bool? result;
switch (typeCode)
{
case XmlTypeCode.AnyAtomicType:
// union
result = false;
break;
case XmlTypeCode.Integer:
case XmlTypeCode.NegativeInteger:
case XmlTypeCode.NonNegativeInteger:
case XmlTypeCode.NonPositiveInteger:
case XmlTypeCode.PositiveInteger:
if (configuration.IntegerDataType != null && configuration.IntegerDataType != typeof(string))
result = false;
else
result = null;
break;
case XmlTypeCode.Base64Binary:
case XmlTypeCode.HexBinary:
result = true;
break;
default:
result = null;
break;
}
return result;
}
private void Init (DateTime value, XmlSchemaType xmlType)
{
if (xmlType == null)
throw new ArgumentNullException ("xmlType");
xmlTypeCode = XmlTypeCode.DateTime;
this.dateTimeValue = value;
schemaType = xmlType;
}
private void Init (byte [] value, XmlSchemaType xmlType)
{
if (xmlType == null)
throw new ArgumentNullException ("xmlType");
xmlTypeCode = XmlTypeCode.Base64Binary;
this.bytesValue = value;
schemaType = xmlType;
}
private void Init (bool value, XmlSchemaType xmlType)
{
if (xmlType == null)
throw new ArgumentNullException ("xmlType");
xmlTypeCode = XmlTypeCode.Boolean;
this.booleanValue = value;
schemaType = xmlType;
}
public static XmlSchemaComplexType GetBuiltInComplexType(XmlTypeCode typeCode)
{
if (typeCode == XmlTypeCode.Item)
{
return XmlSchemaComplexType.AnyType;
}
return null;
}
public XQuerySequenceType(XmlTypeCode typeCode, XmlTypeCardinality cardinality, Type clrType)
: this(typeCode, XmlQualifiedNameTest.Wildcard)
{
Cardinality = cardinality;
ParameterType = clrType;
IsNode = TypeCodeIsNodeType(TypeCode);
if (TypeCode != XmlTypeCode.Item && !IsNode)
SchemaType = XmlSchemaType.GetBuiltInSimpleType(TypeCode);
}
private void Init(DateTime value, XmlSchemaType xmlType)
{
if (xmlType == null)
{
throw new ArgumentNullException("xmlType");
}
this.xmlTypeCode = XmlTypeCode.DateTime;
this.dateTimeValue = value;
this.schemaType = xmlType;
}
public SequenceType(XmlTypeCode typeCode, XmlQualifiedNameTest nameTest, XmlSchemaType schemaType, bool isNillable = false)
{
TypeCode = typeCode;
Cardinality = XmlTypeCardinality.One;
NameTest = nameTest;
SchemaType = schemaType;
Nillable = isNillable;
IsNode = TypeCodeIsNodeType(TypeCode);
ItemType = TypeCodeToItemType(TypeCode, SchemaType);
}
/// <summary>
/// Strongly typed indexer.
/// </summary>
public bool this[XmlTypeCode index1, XmlTypeCode index2]
{
get
{
return(this[(int)index1, (int)index2]);
}
// set {
// this[(int)index1, (int)index2] = value;
// }
}
private void Init(float value, XmlSchemaType xmlType)
{
if (xmlType == null)
{
throw new ArgumentNullException("xmlType");
}
xmlTypeCode = XmlTypeCode.Float;
this.floatValue = value;
schemaType = xmlType;
}
internal static FacetsChecker GetFacetsChecker(XmlTypeCode typeCode)
{
if (FacetsCheckerMapping == null)
{
InitMapping();
}
return FacetsCheckerMapping[typeCode];
}
private void Init(double value, XmlSchemaType xmlType)
{
if (xmlType == null)
{
throw new ArgumentNullException("xmlType");
}
xmlTypeCode = XmlTypeCode.Double;
this.doubleValue = value;
schemaType = xmlType;
}
private void Init(byte [] value, XmlSchemaType xmlType)
{
if (xmlType == null)
{
throw new ArgumentNullException("xmlType");
}
xmlTypeCode = XmlTypeCode.Base64Binary;
this.bytesValue = value;
schemaType = xmlType;
}
public static XmlSchemaType GetBuiltInType(XmlTypeCode type)
{
XmlSchemaType t = XmlSchemaType.GetBuiltInSimpleType(type);
if (t != null)
{
return(t);
}
return(XmlSchemaType.GetBuiltInComplexType(type));
}
private void Init(long value, XmlSchemaType xmlType)
{
if (xmlType == null)
{
throw new ArgumentNullException("xmlType");
}
xmlTypeCode = XmlTypeCode.Long;
this.longValue = value;
schemaType = xmlType;
}
private void Init(decimal value, XmlSchemaType xmlType)
{
if (xmlType == null)
{
throw new ArgumentNullException("xmlType");
}
this.xmlTypeCode = XmlTypeCode.Decimal;
this.decimalValue = value;
this.schemaType = xmlType;
}
private void Init(bool value, XmlSchemaType xmlType)
{
if (xmlType == null)
{
throw new ArgumentNullException("xmlType");
}
xmlTypeCode = XmlTypeCode.Boolean;
this.booleanValue = value;
schemaType = xmlType;
}
private void Init(int value, XmlSchemaType xmlType)
{
if (xmlType == null)
{
throw new ArgumentNullException("xmlType");
}
this.xmlTypeCode = XmlTypeCode.Int;
this.intValue = value;
this.schemaType = xmlType;
}
private static Type GetEffectiveType(XmlTypeCode typeCode, XmlSchemaDatatypeVariety variety, GeneratorConfiguration configuration)
{
Type result;
switch (typeCode)
{
case XmlTypeCode.AnyAtomicType:
// union
result = typeof(string);
break;
case XmlTypeCode.AnyUri:
case XmlTypeCode.Duration:
case XmlTypeCode.GDay:
case XmlTypeCode.GMonth:
case XmlTypeCode.GMonthDay:
case XmlTypeCode.GYear:
case XmlTypeCode.GYearMonth:
result = variety == XmlSchemaDatatypeVariety.List ? typeof(string[]) : typeof(string);
break;
case XmlTypeCode.Time:
if (configuration.TimeDataType == null || configuration.TimeDataType == typeof(string))
{
// default to string
result = typeof(string);
}
else
{
// otherwise, use the specified type
result = configuration.TimeDataType;
}
break;
case XmlTypeCode.Integer:
case XmlTypeCode.NegativeInteger:
case XmlTypeCode.NonNegativeInteger:
case XmlTypeCode.NonPositiveInteger:
case XmlTypeCode.PositiveInteger:
if (configuration.IntegerDataType == null || configuration.IntegerDataType == typeof(string))
{
result = typeof(string);
}
else
{
result = configuration.IntegerDataType;
}
break;
default:
result = null;
break;
}
return(result);
}
public SequenceType(XmlTypeCode typeCode, XmlTypeCardinality cardinality, Type clrType)
: this(typeCode, XmlQualifiedNameTest.Wildcard)
{
Cardinality = cardinality;
ParameterType = clrType;
IsNode = TypeCodeIsNodeType(TypeCode);
if (TypeCode != XmlTypeCode.Item && !IsNode)
{
SchemaType = XmlSchemaType.GetBuiltInSimpleType(TypeCode);
}
}
public SequenceType(XmlTypeCode typeCode, XmlQualifiedNameTest nameTest)
{
TypeCode = typeCode;
Cardinality = XmlTypeCardinality.One;
NameTest = nameTest;
IsNode = TypeCodeIsNodeType(TypeCode);
if (TypeCode != XmlTypeCode.Item && !IsNode)
{
SchemaType = XmlSchemaType.GetBuiltInSimpleType(TypeCode);
}
ItemType = TypeCodeToItemType(TypeCode, SchemaType);
}
public SequenceType(XmlTypeCode typeCode, IXmlSchemaInfo schemaInfo, Type clrType)
{
TypeCode = typeCode;
NameTest = XmlQualifiedNameTest.Wildcard;
Cardinality = XmlTypeCardinality.One;
SchemaType = schemaInfo.SchemaType;
SchemaElement = schemaInfo.SchemaElement;
SchemaAttribute = schemaInfo.SchemaAttribute;
ParameterType = clrType;
IsNode = TypeCodeIsNodeType(TypeCode);
ItemType = TypeCodeToItemType(TypeCode, SchemaType);
}
public FacetsCompiler(DatatypeImplementation baseDatatype, RestrictionFacets restriction) {
firstPattern = true;
regStr = null;
pattern_facet = null;
datatype = baseDatatype;
derivedRestriction = restriction;
baseFlags = datatype.Restriction != null ? datatype.Restriction.Flags : 0;
baseFixedFlags = datatype.Restriction != null ? datatype.Restriction.FixedFlags : 0;
validRestrictionFlags = datatype.ValidRestrictionFlags;
nonNegativeInt = DatatypeImplementation.GetSimpleTypeFromTypeCode(XmlTypeCode.NonNegativeInteger).Datatype;
builtInEnum = !(datatype is Datatype_union || datatype is Datatype_List) ? datatype.TypeCode : 0;
builtInType = (int)builtInEnum > 0 ? DatatypeImplementation.GetSimpleTypeFromTypeCode(builtInEnum).Datatype : datatype;
}
private Exception TryMatchAtomicType(object value, NameTable nameTable, XNamespaceResolver resolver)
{
XmlSchemaDatatype datatype = DataType;
XmlTypeCode typeCode = datatype.TypeCode;
Exception exception = null;
try {
datatype.ChangeType(value, DataType.ValueType, resolver);
}
catch (Exception e) {
exception = e;
}
return(exception);
}
public static Type GetDotNetType(this XmlTypeCode typeCode)
{
var objectMapping = TypeMapper.ObjectMappings.SingleOrDefault(p => p.Value.MappedToType.AsCaseless() == typeCode.ToString());
if (DotNetMappings.Any(p => p.Value.MappedFromType == objectMapping.Value.MappedFromType))
{
var dotNetMapping = DotNetMappings.Single(p => p.Value.MappedFromType == objectMapping.Value.MappedFromType);
var type = Type.GetType("System." + dotNetMapping.Value.MappedToType, true);
return(type);
}
return(null);
}
public FacetsCompiler(DatatypeImplementation baseDatatype, RestrictionFacets restriction)
{
_firstPattern = true;
_regStr = null;
_pattern_facet = null;
_datatype = baseDatatype;
_derivedRestriction = restriction;
_baseFlags = _datatype.Restriction != null ? _datatype.Restriction.Flags : 0;
_baseFixedFlags = _datatype.Restriction != null ? _datatype.Restriction.FixedFlags : 0;
_validRestrictionFlags = _datatype.ValidRestrictionFlags;
_nonNegativeInt = DatatypeImplementation.GetSimpleTypeFromTypeCode(XmlTypeCode.NonNegativeInteger).Datatype;
_builtInEnum = !(_datatype is Datatype_union || _datatype is Datatype_List) ? _datatype.TypeCode : 0;
_builtInType = (int)_builtInEnum > 0 ? DatatypeImplementation.GetSimpleTypeFromTypeCode(_builtInEnum).Datatype : _datatype;
}
public FacetsCompiler(DatatypeImplementation baseDatatype, RestrictionFacets restriction)
{
this.firstPattern = true;
this.regStr = null;
this.pattern_facet = null;
this.datatype = baseDatatype;
this.derivedRestriction = restriction;
this.baseFlags = (this.datatype.Restriction != null) ? this.datatype.Restriction.Flags : ((RestrictionFlags)0);
this.baseFixedFlags = (this.datatype.Restriction != null) ? this.datatype.Restriction.FixedFlags : ((RestrictionFlags)0);
this.validRestrictionFlags = this.datatype.ValidRestrictionFlags;
this.nonNegativeInt = DatatypeImplementation.GetSimpleTypeFromTypeCode(XmlTypeCode.NonNegativeInteger).Datatype;
this.builtInEnum = (!(this.datatype is Datatype_union) && !(this.datatype is Datatype_List)) ? this.datatype.TypeCode : XmlTypeCode.None;
this.builtInType = (this.builtInEnum > XmlTypeCode.None) ? DatatypeImplementation.GetSimpleTypeFromTypeCode(this.builtInEnum).Datatype : this.datatype;
}
private void Init(string value, XmlSchemaType xmlType)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
if (xmlType == null)
{
throw new ArgumentNullException("xmlType");
}
this.xmlTypeCode = XmlTypeCode.String;
this.stringValue = value;
this.schemaType = xmlType;
}
internal static Type RuntimeTypeFromXmlTypeCode(XmlTypeCode typeCode)
{
switch (typeCode)
{
case XmlTypeCode.Long:
return(typeof(long));
case XmlTypeCode.Int:
return(typeof(int));
case XmlTypeCode.Short:
return(typeof(short));
default:
switch (typeCode)
{
case XmlTypeCode.String:
return(typeof(string));
case XmlTypeCode.Boolean:
return(typeof(bool));
case XmlTypeCode.Decimal:
return(typeof(decimal));
case XmlTypeCode.Float:
return(typeof(float));
case XmlTypeCode.Double:
return(typeof(double));
default:
if (typeCode != XmlTypeCode.Item)
{
throw new NotSupportedException(string.Format("XQuery internal error: Cannot infer Runtime Type from XmlTypeCode {0}.", typeCode));
}
return(typeof(object));
case XmlTypeCode.DateTime:
return(typeof(DateTime));
}
break;
case XmlTypeCode.UnsignedInt:
return(typeof(uint));
case XmlTypeCode.UnsignedShort:
return(typeof(ushort));
}
}
private Exception CheckBuiltInFacets(string s, XmlTypeCode typeCode, bool verifyUri)
{
Exception exception = null;
switch (typeCode)
{
case XmlTypeCode.AnyUri:
if (verifyUri)
{
Uri uri;
exception = XmlConvert.TryToUri(s, out uri);
}
return(exception);
case XmlTypeCode.QName:
case XmlTypeCode.Notation:
return(exception);
case XmlTypeCode.NormalizedString:
return(XmlConvert.TryVerifyNormalizedString(s));
case XmlTypeCode.Token:
return(XmlConvert.TryVerifyTOKEN(s));
case XmlTypeCode.Language:
if ((s != null) && (s.Length != 0))
{
if (!LanguagePattern.IsMatch(s))
{
return(new XmlSchemaException("Sch_InvalidLanguageId", string.Empty));
}
return(exception);
}
return(new XmlSchemaException("Sch_EmptyAttributeValue", string.Empty));
case XmlTypeCode.NmToken:
return(XmlConvert.TryVerifyNMTOKEN(s));
case XmlTypeCode.Name:
return(XmlConvert.TryVerifyName(s));
case XmlTypeCode.NCName:
case XmlTypeCode.Id:
case XmlTypeCode.Idref:
case XmlTypeCode.Entity:
return(XmlConvert.TryVerifyNCName(s));
}
return(exception);
}
/// <summary>
/// Return true if the type of "item" is a subtype of the type identified by "code".
/// </summary>
public bool MatchesXmlType(XPathItem item, XmlTypeCode code)
{
// All atomic type codes appear after AnyAtomicType
if (code > XmlTypeCode.AnyAtomicType)
{
return(!item.IsNode && item.XmlType.TypeCode == code);
}
// Handle node code and AnyAtomicType
switch (code)
{
case XmlTypeCode.AnyAtomicType: return(!item.IsNode);
case XmlTypeCode.Node: return(item.IsNode);
case XmlTypeCode.Item: return(true);
default:
if (!item.IsNode)
{
return(false);
}
switch (((XPathNavigator)item).NodeType)
{
case XPathNodeType.Root: return(code == XmlTypeCode.Document);
case XPathNodeType.Element: return(code == XmlTypeCode.Element);
case XPathNodeType.Attribute: return(code == XmlTypeCode.Attribute);
case XPathNodeType.Namespace: return(code == XmlTypeCode.Namespace);
case XPathNodeType.Text: return(code == XmlTypeCode.Text);
case XPathNodeType.SignificantWhitespace: return(code == XmlTypeCode.Text);
case XPathNodeType.Whitespace: return(code == XmlTypeCode.Text);
case XPathNodeType.ProcessingInstruction: return(code == XmlTypeCode.ProcessingInstruction);
case XPathNodeType.Comment: return(code == XmlTypeCode.Comment);
}
break;
}
Debug.Fail("XmlTypeCode " + code + " was not fully handled.");
return(false);
}
public static bool TypeCodeIsNodeType(XmlTypeCode typeCode)
{
switch (typeCode)
{
case XmlTypeCode.Node:
case XmlTypeCode.Element:
case XmlTypeCode.Attribute:
case XmlTypeCode.Document:
case XmlTypeCode.Comment:
case XmlTypeCode.Text:
case XmlTypeCode.ProcessingInstruction:
return(true);
}
return(false);
}
protected XmlBaseConverter(XmlSchemaType schemaType)
{
XmlSchemaDatatype datatype = schemaType.Datatype;
while ((schemaType != null) && !(schemaType is XmlSchemaSimpleType))
{
schemaType = schemaType.BaseXmlSchemaType;
}
if (schemaType == null)
{
schemaType = XmlSchemaType.GetBuiltInSimpleType(datatype.TypeCode);
}
this.schemaType = schemaType;
this.typeCode = schemaType.TypeCode;
this.clrTypeDefault = schemaType.Datatype.ValueType;
}
private Exception CheckBuiltInFacets(string s, XmlTypeCode typeCode, bool verifyUri)
{
Exception exception = null;
switch (typeCode)
{
case XmlTypeCode.AnyUri:
if (verifyUri)
{
Uri uri;
exception = XmlConvert.TryToUri(s, out uri);
}
return exception;
case XmlTypeCode.QName:
case XmlTypeCode.Notation:
return exception;
case XmlTypeCode.NormalizedString:
return XmlConvert.TryVerifyNormalizedString(s);
case XmlTypeCode.Token:
return XmlConvert.TryVerifyTOKEN(s);
case XmlTypeCode.Language:
if ((s != null) && (s.Length != 0))
{
if (!LanguagePattern.IsMatch(s))
{
return new XmlSchemaException("Sch_InvalidLanguageId", string.Empty);
}
return exception;
}
return new XmlSchemaException("Sch_EmptyAttributeValue", string.Empty);
case XmlTypeCode.NmToken:
return XmlConvert.TryVerifyNMTOKEN(s);
case XmlTypeCode.Name:
return XmlConvert.TryVerifyName(s);
case XmlTypeCode.NCName:
case XmlTypeCode.Id:
case XmlTypeCode.Idref:
case XmlTypeCode.Entity:
return XmlConvert.TryVerifyNCName(s);
}
return exception;
}
protected XmlBaseConverter(XmlSchemaType schemaType)
{
XmlSchemaDatatype datatype = schemaType.Datatype;
while ((schemaType != null) && !(schemaType is XmlSchemaSimpleType))
{
schemaType = schemaType.BaseXmlSchemaType;
}
if (schemaType == null)
{
schemaType = XmlSchemaType.GetBuiltInSimpleType(datatype.TypeCode);
}
this.schemaType = schemaType;
this.typeCode = schemaType.TypeCode;
this.clrTypeDefault = schemaType.Datatype.ValueType;
}
private static bool TryParseCode(string value, out XmlTypeCode code)
{
if (value != null)
{
try
{
code = (XmlTypeCode)Enum.Parse(typeof(XmlTypeCode), value, true);
return(true);
}
catch (FormatException)
{
}
}
code = XmlTypeCode.None;
return(false);
}
public QilNode ConvertToType(XmlTypeCode requiredType, QilNode n)
{
switch (requiredType)
{
case XmlTypeCode.String: return(ConvertToString(n));
case XmlTypeCode.Double: return(ConvertToNumber(n));
case XmlTypeCode.Boolean: return(ConvertToBoolean(n));
case XmlTypeCode.Node: return(EnsureNodeSet(n));
case XmlTypeCode.Item: return(n);
default: Debug.Fail("Unexpected XmlTypeCode: " + requiredType); return(null);
}
}
public static XmlTypeCode GetFallbackType (XmlTypeCode type)
{
switch (type) {
case XmlTypeCode.AnyAtomicType:
return XmlTypeCode.Item;
case XmlTypeCode.UntypedAtomic:
return XmlTypeCode.String;
case XmlTypeCode.Notation:
return XmlTypeCode.QName;
case XmlTypeCode.NormalizedString:
case XmlTypeCode.Token:
case XmlTypeCode.Language:
case XmlTypeCode.NmToken:
case XmlTypeCode.Name:
case XmlTypeCode.NCName:
case XmlTypeCode.Id:
case XmlTypeCode.Idref:
case XmlTypeCode.Entity:
return XmlTypeCode.String;
case XmlTypeCode.NonPositiveInteger:
return XmlTypeCode.Decimal;
case XmlTypeCode.NegativeInteger:
return XmlTypeCode.NonPositiveInteger;
case XmlTypeCode.Long:
return XmlTypeCode.Integer;
case XmlTypeCode.Short:
return XmlTypeCode.Int;
case XmlTypeCode.Byte:
return XmlTypeCode.Int;
case XmlTypeCode.NonNegativeInteger:
return XmlTypeCode.Decimal;
case XmlTypeCode.UnsignedLong:
return XmlTypeCode.NonNegativeInteger;
case XmlTypeCode.UnsignedInt:
return XmlTypeCode.Integer;
case XmlTypeCode.UnsignedShort:
return XmlTypeCode.Int;
case XmlTypeCode.UnsignedByte:
return XmlTypeCode.UnsignedShort;
case XmlTypeCode.PositiveInteger:
return XmlTypeCode.NonNegativeInteger;
default:
return XmlTypeCode.None;
}
}
/// <summary>Returns the validated XML element or attribute's value as the type specified using the <see cref="T:System.Xml.IXmlNamespaceResolver" /> object specified to resolve namespace prefixes.</summary>
/// <returns>The value of the validated XML element or attribute as the type requested.</returns>
/// <param name="type">The type to return the validated XML element or attribute's value as.</param>
/// <param name="nsResolver">The <see cref="T:System.Xml.IXmlNamespaceResolver" /> object used to resolve namespace prefixes.</param>
/// <exception cref="T:System.FormatException">The validated XML element or attribute's value is not in the correct format for the target type.</exception>
/// <exception cref="T:System.InvalidCastException">The attempted cast is not valid.</exception>
/// <exception cref="T:System.OverflowException">The attempted cast resulted in an overflow.</exception>
public override object ValueAs(Type type, IXmlNamespaceResolver nsResolver)
{
XmlTypeCode xmlTypeCode = XmlAtomicValue.XmlTypeCodeFromRuntimeType(type, false);
switch (xmlTypeCode)
{
case XmlTypeCode.Long:
case XmlTypeCode.UnsignedInt:
return(this.ValueAsLong);
case XmlTypeCode.Int:
case XmlTypeCode.Short:
case XmlTypeCode.UnsignedShort:
return(this.ValueAsInt);
default:
switch (xmlTypeCode)
{
case XmlTypeCode.String:
return(this.Value);
case XmlTypeCode.Boolean:
return(this.ValueAsBoolean);
default:
if (xmlTypeCode == XmlTypeCode.Item)
{
return(this.TypedValue);
}
if (xmlTypeCode != XmlTypeCode.QName)
{
throw new NotImplementedException();
}
return(XmlQualifiedName.Parse(this.Value, nsResolver, true));
case XmlTypeCode.Float:
case XmlTypeCode.Double:
return(this.ValueAsDouble);
case XmlTypeCode.DateTime:
return(this.ValueAsDateTime);
}
break;
}
}
protected XmlBaseConverter(XmlTypeCode typeCode)
{
switch (typeCode)
{
case XmlTypeCode.Item:
this.clrTypeDefault = XPathItemType;
break;
case XmlTypeCode.Node:
this.clrTypeDefault = XPathNavigatorType;
break;
case XmlTypeCode.AnyAtomicType:
this.clrTypeDefault = XmlAtomicValueType;
break;
}
this.typeCode = typeCode;
}
internal override bool IsComparable(XmlSchemaDatatype dtype)
{
XmlTypeCode typeCode = this.TypeCode;
XmlTypeCode code2 = dtype.TypeCode;
if (typeCode != code2)
{
if (GetPrimitiveTypeCode(typeCode) == GetPrimitiveTypeCode(code2))
{
return(true);
}
if (!this.IsDerivedFrom(dtype) && !dtype.IsDerivedFrom(this))
{
return(false);
}
}
return(true);
}
protected XmlBaseConverter(XmlTypeCode typeCode)
{
switch (typeCode)
{
case XmlTypeCode.Item:
this.clrTypeDefault = XPathItemType;
break;
case XmlTypeCode.Node:
this.clrTypeDefault = XPathNavigatorType;
break;
case XmlTypeCode.AnyAtomicType:
this.clrTypeDefault = XmlAtomicValueType;
break;
}
this.typeCode = typeCode;
}
private XmlTypeCode GetExcelType(XmlTypeCode typeCode)
{
//DateTime
//double
//string
//bool
if (typeCode == XmlTypeCode.DateTime || typeCode == XmlTypeCode.Boolean || typeCode == XmlTypeCode.String || typeCode == XmlTypeCode.Double)
{
return(typeCode);
}
if (typeCode == XmlTypeCode.Float || typeCode == XmlTypeCode.Decimal)
{
return(XmlTypeCode.Double);
}
else
{
return(XmlTypeCode.String);
}
}
private static Type GetEffectiveType(XmlTypeCode typeCode, XmlSchemaDatatypeVariety variety, GeneratorConfiguration configuration)
{
Type result;
switch (typeCode)
{
case XmlTypeCode.AnyAtomicType:
// union
result = typeof(string);
break;
case XmlTypeCode.AnyUri:
case XmlTypeCode.Duration:
case XmlTypeCode.GDay:
case XmlTypeCode.GMonth:
case XmlTypeCode.GMonthDay:
case XmlTypeCode.GYear:
case XmlTypeCode.GYearMonth:
case XmlTypeCode.Time:
result = variety == XmlSchemaDatatypeVariety.List ? typeof(string[]) : typeof(string);
break;
case XmlTypeCode.Integer:
case XmlTypeCode.NegativeInteger:
case XmlTypeCode.NonNegativeInteger:
case XmlTypeCode.NonPositiveInteger:
case XmlTypeCode.PositiveInteger:
if (configuration.IntegerDataType == null || configuration.IntegerDataType == typeof(string))
result = typeof(string);
else
{
result = configuration.IntegerDataType;
}
break;
default:
result = null;
break;
}
return result;
}
/// <include file='doc\XmlSchemaType.uex' path='docs/doc[@for="XmlSchemaType.GetXsdSimpleType"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public static XmlSchemaSimpleType GetBuiltInSimpleType(XmlTypeCode typeCode) {
return DatatypeImplementation.GetSimpleTypeFromTypeCode(typeCode);
}
private Exception CheckBuiltInFacets(string s, XmlTypeCode typeCode, bool verifyUri) {
Exception exception = null;
switch (typeCode) {
case XmlTypeCode.AnyUri:
if (verifyUri) {
Uri uri;
exception = XmlConvert.TryToUri(s, out uri);
}
break;
case XmlTypeCode.NormalizedString:
exception = XmlConvert.TryVerifyNormalizedString(s);
break;
case XmlTypeCode.Token:
exception = XmlConvert.TryVerifyTOKEN(s);
break;
case XmlTypeCode.Language:
if (s == null || s.Length == 0) {
return new XmlSchemaException(Res.Sch_EmptyAttributeValue, string.Empty);
}
if (!LanguagePattern.IsMatch(s)) {
return new XmlSchemaException(Res.Sch_InvalidLanguageId, string.Empty);
}
break;
case XmlTypeCode.NmToken:
exception = XmlConvert.TryVerifyNMTOKEN(s);
break;
case XmlTypeCode.Name:
exception = XmlConvert.TryVerifyName(s);
break;
case XmlTypeCode.NCName:
case XmlTypeCode.Id:
case XmlTypeCode.Idref:
case XmlTypeCode.Entity:
exception = XmlConvert.TryVerifyNCName(s);
break;
default:
break;
}
return exception;
}
public QilNode ConvertToType(XmlTypeCode requiredType, QilNode n) {
switch (requiredType) {
case XmlTypeCode.String : return ConvertToString(n);
case XmlTypeCode.Double : return ConvertToNumber(n);
case XmlTypeCode.Boolean : return ConvertToBoolean(n);
case XmlTypeCode.Node : return EnsureNodeSet(n);
case XmlTypeCode.Item : return n;
default : Debug.Fail("Unexpected XmlTypeCode: " + requiredType); return null;
}
}
internal static XmlTypeCode GetPrimitiveTypeCode(XmlTypeCode typeCode) {
XmlSchemaSimpleType currentType = enumToTypeCode[(int)typeCode];
while (currentType.BaseXmlSchemaType != DatatypeImplementation.AnySimpleType) {
currentType = currentType.BaseXmlSchemaType as XmlSchemaSimpleType;
Debug.Assert(currentType != null);
}
return currentType.TypeCode;
}
internal static XmlSchemaSimpleType GetSimpleTypeFromTypeCode(XmlTypeCode typeCode) {
return enumToTypeCode[(int) typeCode];
}
/// <summary>
/// Private constructor. Create methods should be used to create instances.
/// </summary>
private ItemType(XmlTypeCode code, XmlQualifiedNameTest nameTest, XmlSchemaType schemaType, bool isNillable, bool isStrict, bool isNotRtf) {
Debug.Assert(nameTest != null, "nameTest cannot be null");
Debug.Assert(schemaType != null, "schemaType cannot be null");
this.code = code;
this.nameTest = nameTest;
this.schemaType = schemaType;
this.isNillable = isNillable;
this.isStrict = isStrict;
this.isNotRtf = isNotRtf;
Debug.Assert(!IsAtomicValue || schemaType.Datatype.Variety == XmlSchemaDatatypeVariety.Atomic);
switch (code) {
case XmlTypeCode.Item: this.nodeKinds = XmlNodeKindFlags.Any; break;
case XmlTypeCode.Node: this.nodeKinds = XmlNodeKindFlags.Any; break;
case XmlTypeCode.Document: this.nodeKinds = XmlNodeKindFlags.Document; break;
case XmlTypeCode.Element: this.nodeKinds = XmlNodeKindFlags.Element; break;
case XmlTypeCode.Attribute: this.nodeKinds = XmlNodeKindFlags.Attribute; break;
case XmlTypeCode.Namespace: this.nodeKinds = XmlNodeKindFlags.Namespace; break;
case XmlTypeCode.ProcessingInstruction: this.nodeKinds = XmlNodeKindFlags.PI; break;
case XmlTypeCode.Comment: this.nodeKinds = XmlNodeKindFlags.Comment; break;
case XmlTypeCode.Text: this.nodeKinds = XmlNodeKindFlags.Text; break;
default: this.nodeKinds = XmlNodeKindFlags.None; break;
}
}
//-----------------------------------------------
// Serialization
//-----------------------------------------------
/// <summary>
/// Serialize the object to BinaryWriter.
/// </summary>
public override void GetObjectData(BinaryWriter writer) {
sbyte code = (sbyte) this.code;
for (int idx = 0; idx < SpecialBuiltInItemTypes.Length; idx++) {
if ((object) this == (object) SpecialBuiltInItemTypes[idx]) {
code = (sbyte) ~idx;
break;
}
}
writer.Write(code);
if (0 <= code) {
Debug.Assert((object) this == (object) Create(this.code, this.isStrict), "Unknown type");
writer.Write(this.isStrict);
}
}
/// <summary>
/// Private constructor. Create methods should be used to create instances.
/// </summary>
private ChoiceType(List<XmlQueryType> members) {
Debug.Assert(members != null && members.Count != 1, "ChoiceType must contain a list with 0 or >1 types.");
this.members = members;
// Compute supertype of all member types
for (int i = 0; i < members.Count; i++) {
XmlQueryType t = members[i];
Debug.Assert(t.Cardinality == XmlQueryCardinality.One, "ChoiceType member types must be prime types.");
// Summarize the union of member types as a single type
if (this.code == XmlTypeCode.None) {
// None combined with member type is the member type
this.code = t.TypeCode;
this.schemaType = t.SchemaType;
}
else if (IsNode && t.IsNode) {
// Node combined with node is node
if (this.code == t.TypeCode) {
// Element or attribute combined with element or attribute can be summarized as element(*, XmlSchemaComplexType.AnyType) or attribute(*, DatatypeImplementation.AnySimpleType)
if (this.code == XmlTypeCode.Element)
this.schemaType = XmlSchemaComplexType.AnyType;
else if (this.code == XmlTypeCode.Attribute)
this.schemaType = DatatypeImplementation.AnySimpleType;
}
else {
this.code = XmlTypeCode.Node;
this.schemaType = null;
}
}
else if (IsAtomicValue && t.IsAtomicValue) {
// Atomic value combined with atomic value is atomic value
this.code = XmlTypeCode.AnyAtomicType;
this.schemaType = DatatypeImplementation.AnyAtomicType;
}
else {
// Else we'll summarize types as Item
this.code = XmlTypeCode.Item;
this.schemaType = null;
}
// Always track union of node kinds
this.nodeKinds |= t.NodeKinds;
}
}
/// <summary>
/// Return true if the type of "item" is a subtype of the type identified by "code".
/// </summary>
public bool MatchesXmlType(XPathItem item, XmlTypeCode code) {
// All atomic type codes appear after AnyAtomicType
if (code > XmlTypeCode.AnyAtomicType)
return !item.IsNode && item.XmlType.TypeCode == code;
// Handle node code and AnyAtomicType
switch (code) {
case XmlTypeCode.AnyAtomicType: return !item.IsNode;
case XmlTypeCode.Node: return item.IsNode;
case XmlTypeCode.Item: return true;
default:
if (!item.IsNode)
return false;
switch (((XPathNavigator) item).NodeType) {
case XPathNodeType.Root: return code == XmlTypeCode.Document;
case XPathNodeType.Element: return code == XmlTypeCode.Element;
case XPathNodeType.Attribute: return code == XmlTypeCode.Attribute;
case XPathNodeType.Namespace: return code == XmlTypeCode.Namespace;
case XPathNodeType.Text: return code == XmlTypeCode.Text;
case XPathNodeType.SignificantWhitespace: return code == XmlTypeCode.Text;
case XPathNodeType.Whitespace: return code == XmlTypeCode.Text;
case XPathNodeType.ProcessingInstruction: return code == XmlTypeCode.ProcessingInstruction;
case XPathNodeType.Comment: return code == XmlTypeCode.Comment;
}
break;
}
Debug.Fail("XmlTypeCode " + code + " was not fully handled.");
return false;
}
/// <summary>
/// Return true if the type of "seq" is a subtype of a singleton type identified by "code".
/// </summary>
public bool MatchesXmlType(IList<XPathItem> seq, XmlTypeCode code) {
if (seq.Count != 1)
return false;
return MatchesXmlType(seq[0], code);
}
private bool IsIntegralType(XmlTypeCode defaultTypeCode) {
switch (defaultTypeCode) {
case XmlTypeCode.Integer:
case XmlTypeCode.NegativeInteger:
case XmlTypeCode.NonNegativeInteger:
case XmlTypeCode.NonPositiveInteger:
case XmlTypeCode.PositiveInteger:
case XmlTypeCode.Long:
case XmlTypeCode.Int:
case XmlTypeCode.Short:
case XmlTypeCode.Byte:
case XmlTypeCode.UnsignedLong:
case XmlTypeCode.UnsignedInt:
case XmlTypeCode.UnsignedShort:
case XmlTypeCode.UnsignedByte:
return true;
default:
return false;
}
}
private Exception CheckBuiltInFacets(string s, XmlTypeCode typeCode, bool verifyUri)
{
Exception exception = null;
switch (typeCode) {
case XmlTypeCode.AnyUri:
if (verifyUri) {
Uri uri = null;
exception = XmlConvertExt.TryToUri(s, out uri);
}
break;
case XmlTypeCode.NormalizedString:
exception = XmlConvertExt.VerifyNormalizedString(s);
break;
case XmlTypeCode.Token:
try
{
XmlConvert.VerifyTOKEN(s);
}
catch (Exception e)
{
exception = e;
}
break;
case XmlTypeCode.Language:
if (s == null || s.Length == 0) {
exception = new LinqToXsdException();
}
if (!LanguagePattern.IsMatch(s)) {
exception = new LinqToXsdException();
}
break;
case XmlTypeCode.NmToken:
try
{
XmlConvert.VerifyNMTOKEN(s);
}
catch (Exception e)
{
exception = e;
}
break;
case XmlTypeCode.Name:
try
{
XmlConvert.VerifyName(s);
}
catch(Exception e) {
exception = e;
}
break;
case XmlTypeCode.NCName:
case XmlTypeCode.Id:
case XmlTypeCode.Idref:
case XmlTypeCode.Entity:
try
{
XmlConvert.VerifyNCName(s);
}
catch (Exception e)
{
exception = e;
}
break;
default:
break;
}
return exception;
}
public void CallCompare(XmlTypeCode code)
{
MethodInfo meth = null;
switch (code)
{
case XmlTypeCode.String: meth = XmlILMethods.StrCmp; break;
case XmlTypeCode.Decimal: meth = XmlILMethods.DecCmp; break;
default:
Debug.Assert(false, "Type " + code + " does not support the equals operation.");
break;
}
Call(meth);
}
public void CallArithmeticOp(QilNodeType opType, XmlTypeCode code)
{
MethodInfo meth = null;
switch (code)
{
case XmlTypeCode.Int:
case XmlTypeCode.Integer:
case XmlTypeCode.Double:
case XmlTypeCode.Float:
switch (opType)
{
case QilNodeType.Add: Emit(OpCodes.Add); break;
case QilNodeType.Subtract: Emit(OpCodes.Sub); break;
case QilNodeType.Multiply: Emit(OpCodes.Mul); break;
case QilNodeType.Divide: Emit(OpCodes.Div); break;
case QilNodeType.Modulo: Emit(OpCodes.Rem); break;
case QilNodeType.Negate: Emit(OpCodes.Neg); break;
default: Debug.Assert(false, opType + " must be an arithmetic operation."); break;
}
break;
case XmlTypeCode.Decimal:
switch (opType)
{
case QilNodeType.Add: meth = XmlILMethods.DecAdd; break;
case QilNodeType.Subtract: meth = XmlILMethods.DecSub; break;
case QilNodeType.Multiply: meth = XmlILMethods.DecMul; break;
case QilNodeType.Divide: meth = XmlILMethods.DecDiv; break;
case QilNodeType.Modulo: meth = XmlILMethods.DecRem; break;
case QilNodeType.Negate: meth = XmlILMethods.DecNeg; break;
default: Debug.Assert(false, opType + " must be an arithmetic operation."); break;
}
Call(meth);
break;
default:
Debug.Assert(false, "The " + opType + " arithmetic operation cannot be performed on values of type " + code + ".");
break;
}
}
internal string TypeCodeToString(XmlTypeCode typeCode)
{
switch (typeCode)
{
case XmlTypeCode.None:
return "None";
case XmlTypeCode.Item:
return "AnyType";
case XmlTypeCode.AnyAtomicType:
return "AnyAtomicType";
case XmlTypeCode.String:
return "String";
case XmlTypeCode.Boolean:
return "Boolean";
case XmlTypeCode.Decimal:
return "Decimal";
case XmlTypeCode.Float:
return "Float";
case XmlTypeCode.Double:
return "Double";
case XmlTypeCode.Duration:
return "Duration";
case XmlTypeCode.DateTime:
return "DateTime";
case XmlTypeCode.Time:
return "Time";
case XmlTypeCode.Date:
return "Date";
case XmlTypeCode.GYearMonth:
return "GYearMonth";
case XmlTypeCode.GYear:
return "GYear";
case XmlTypeCode.GMonthDay:
return "GMonthDay";
case XmlTypeCode.GDay:
return "GDay";
case XmlTypeCode.GMonth:
return "GMonth";
case XmlTypeCode.HexBinary:
return "HexBinary";
case XmlTypeCode.Base64Binary:
return "Base64Binary";
case XmlTypeCode.AnyUri:
return "AnyUri";
case XmlTypeCode.QName:
return "QName";
case XmlTypeCode.Notation:
return "Notation";
case XmlTypeCode.NormalizedString:
return "NormalizedString";
case XmlTypeCode.Token:
return "Token";
case XmlTypeCode.Language:
return "Language";
case XmlTypeCode.NmToken:
return "NmToken";
case XmlTypeCode.Name:
return "Name";
case XmlTypeCode.NCName:
return "NCName";
case XmlTypeCode.Id:
return "Id";
case XmlTypeCode.Idref:
return "Idref";
case XmlTypeCode.Entity:
return "Entity";
case XmlTypeCode.Integer:
return "Integer";
case XmlTypeCode.NonPositiveInteger:
return "NonPositiveInteger";
case XmlTypeCode.NegativeInteger:
return "NegativeInteger";
case XmlTypeCode.Long:
return "Long";
case XmlTypeCode.Int:
return "Int";
case XmlTypeCode.Short:
return "Short";
case XmlTypeCode.Byte:
return "Byte";
case XmlTypeCode.NonNegativeInteger:
return "NonNegativeInteger";
case XmlTypeCode.UnsignedLong:
return "UnsignedLong";
case XmlTypeCode.UnsignedInt:
return "UnsignedInt";
case XmlTypeCode.UnsignedShort:
return "UnsignedShort";
case XmlTypeCode.UnsignedByte:
return "UnsignedByte";
case XmlTypeCode.PositiveInteger:
return "PositiveInteger";
default:
return typeCode.ToString();
}
}