Exemple #1
0
        static QName GetAtomicSchemaType(XPathItemType itemType)
        {
            if (itemType.AtomicTypeOrNodeName != null)
            {
                return(new QName(itemType.AtomicTypeOrNodeName));
            }

            Type clrType = itemType.ClrType;

            switch (Type.GetTypeCode(clrType))
            {
            case TypeCode.Boolean:
                return(QName.XS_BOOLEAN);

            case TypeCode.DateTime:
                return(new QName(XMLSchemaNamespace, "xs:dateTime"));

            case TypeCode.Decimal:
                return(QName.XS_DECIMAL);

            case TypeCode.Double:
                return(QName.XS_DOUBLE);

            case TypeCode.SByte:
            case TypeCode.Byte:
            case TypeCode.Int16:
            case TypeCode.Int32:
            case TypeCode.Int64:
            case TypeCode.UInt16:
            case TypeCode.UInt32:
            case TypeCode.UInt64:
                return(QName.XS_INTEGER);

            case TypeCode.Single:
                return(QName.XS_FLOAT);

            default:
            case TypeCode.String:
                return(QName.XS_STRING);

            case TypeCode.Object:

                if (clrType == typeof(QName) ||
                    clrType == typeof(XmlQualifiedName))
                {
                    return(QName.XS_QNAME);
                }

                if (clrType == typeof(Uri))
                {
                    return(QName.XS_ANYURI);
                }

                return(new QName(XMLSchemaNamespace, "xs:anyAtomicType"));
            }
        }
Exemple #2
0
        static CodeExpression GetXdmItemTypeExpression(XPathItemType itemType)
        {
            switch (itemType.Kind)
            {
            case XPathItemKind.AnyItem:
                return(new CodeFieldReferenceExpression(
                           new CodeTypeReferenceExpression(typeof(XdmAnyItemType)),
                           "Instance"
                           ));

            case XPathItemKind.Atomic:

                CodeExpression qnameRef = null;

                QName atomicSchemaType = GetAtomicSchemaType(itemType);

                if (atomicSchemaType.Uri == XMLSchemaNamespace)
                {
                    FieldInfo qnameField = typeof(QName).GetField("XS_" + atomicSchemaType.LocalName.ToUpperInvariant(), BindingFlags.Public | BindingFlags.Static);

                    if (qnameField != null)
                    {
                        qnameRef = new CodeFieldReferenceExpression {
                            FieldName    = qnameField.Name,
                            TargetObject = new CodeTypeReferenceExpression(typeof(QName))
                        };
                    }
                }

                if (qnameRef == null)
                {
                    qnameRef = new CodeObjectCreateExpression(
                        typeof(QName),
                        new CodePrimitiveExpression(atomicSchemaType.Uri),
                        new CodePrimitiveExpression(atomicSchemaType.LocalName)
                        );
                }

                return(new CodeMethodInvokeExpression {
                    Method = new CodeMethodReferenceExpression {
                        MethodName = "BuiltInAtomicType",
                        TargetObject = new CodeTypeReferenceExpression(typeof(XdmAtomicType))
                    },
                    Parameters =
                    {
                        qnameRef
                    }
                });

            case XPathItemKind.AnyNode:
                return(new CodeFieldReferenceExpression(
                           new CodeTypeReferenceExpression(typeof(XdmAnyNodeType)),
                           "Instance"
                           ));

            case XPathItemKind.Attribute:
            case XPathItemKind.SchemaAttribute:
                return(new CodeFieldReferenceExpression(
                           new CodeTypeReferenceExpression(typeof(XdmNodeKind)),
                           "Attribute"
                           ));

            case XPathItemKind.Comment:
                return(new CodeFieldReferenceExpression(
                           new CodeTypeReferenceExpression(typeof(XdmNodeKind)),
                           "Comment"
                           ));

            case XPathItemKind.Document:
                return(new CodeFieldReferenceExpression(
                           new CodeTypeReferenceExpression(typeof(XdmNodeKind)),
                           "Document"
                           ));

            case XPathItemKind.Element:
            case XPathItemKind.SchemaElement:
                return(new CodeFieldReferenceExpression(
                           new CodeTypeReferenceExpression(typeof(XdmNodeKind)),
                           "Element"
                           ));

            case XPathItemKind.ProcessingInstruction:
                return(new CodeFieldReferenceExpression(
                           new CodeTypeReferenceExpression(typeof(XdmNodeKind)),
                           "ProcessingInstruction"
                           ));

            case XPathItemKind.Text:
                return(new CodeFieldReferenceExpression(
                           new CodeTypeReferenceExpression(typeof(XdmNodeKind)),
                           "Text"
                           ));

            default:
                throw new ArgumentException("itemType not supported.", "itemType");
            }
        }