private static Pair <string, XPathResultType> MakeAttributeProperty( SchemaItemAttribute attribute, Property property, XPathNamespaceContext ctx) { var prefix = ctx.LookupPrefix(attribute.Namespace); if (string.IsNullOrEmpty(prefix)) { prefix = ""; } else { prefix += ':'; } if (IsAnySimpleProperty(property)) { var type = SchemaUtil.SimpleTypeToResultType(attribute.SimpleType); var path = "/@" + prefix + property.PropertyNameAtomic; return(new Pair <string, XPathResultType>(path, type)); } if (IsAnyMappedProperty(property)) { throw new Exception("Mapped properties not applicable to attributes"); } throw new Exception("Indexed properties not applicable to attributes"); }
private static Pair <string, XPathResultType> MakeProperty( SchemaElementComplex parent, Property property, XPathNamespaceContext ctx, bool isLast, bool isDynamic, string defaultNamespacePrefix) { var text = property.PropertyNameAtomic; var obj = SchemaUtil.FindPropertyMapping(parent, text); if (obj is SchemaElementSimple || obj is SchemaElementComplex) { return(MakeElementProperty( (SchemaElement)obj, property, ctx, isLast, isDynamic, defaultNamespacePrefix)); } if (obj != null) { return(MakeAttributeProperty((SchemaItemAttribute)obj, property, ctx)); } if (isDynamic) { return(MakeElementProperty(null, property, ctx, isLast, isDynamic, defaultNamespacePrefix)); } return(null); }
private Type DoResolvePropertyType( string propertyExpression, bool allowSimpleProperties) { // see if this is an indexed property var index = StringValue.UnescapedIndexOfDot(propertyExpression); if (!allowSimpleProperties && index == -1) { // parse, can be an indexed property var property = PropertyParser.ParseAndWalkLaxToSimple(propertyExpression); if (!property.IsDynamic) { if (!(property is IndexedProperty)) { return null; } var indexedProp = (IndexedProperty) property; var descriptor = PropertyDescriptorMap.Get(indexedProp.PropertyNameAtomic); return descriptor?.PropertyType; } } var prop = PropertyParser.ParseAndWalkLaxToSimple(propertyExpression); if (prop.IsDynamic) { return typeof(XmlNode); } var item = prop.GetPropertyTypeSchema(schemaModelRoot); if (item == null) { return null; } return SchemaUtil.ToReturnType(item); }
public object Get(EventBean eventBean) { var und = eventBean.Underlying; if (und == null) { throw new PropertyAccessException( "Unexpected null underlying event encountered, expecting org.w3c.dom.XmlNode instance as underlying"); } var xnode = und as XElement; if (xnode == null) { var node = und as XmlNode; if (node == null) { throw new PropertyAccessException( "Unexpected underlying event of type '" + und.GetType().FullName + "' encountered, expecting System.Xml.XmlNode as underlying"); } if (Log.IsDebugEnabled) { Log.Debug( "Running XPath '{0}' for property '{1}' against Node XML : {2}", _expressionText, _property, SchemaUtil.Serialize((XmlNode) und)); } return GetFromUnderlying(node.CreateNavigator()); } return GetFromUnderlying(xnode.CreateNavigator()); }
/// <summary> /// Return the xPath corresponding to the given property. The PropertyName String /// may be simple, nested, indexed or mapped. /// </summary> /// <param name="propertyName">is the event property name</param> /// <param name="namespace">is the default namespace</param> /// <param name="schemaModel">is the schema model</param> /// <param name="xPathContext">is the xpath factory instance to use</param> /// <param name="rootElementName">is the name of the root element</param> /// <param name="eventBeanTypedEventFactory">for type lookup and creation</param> /// <param name="xmlEventType">the resolving type</param> /// <param name="isAllowFragment">whether fragmenting is allowed</param> /// <param name="defaultNamespace">default namespace</param> /// <returns> /// xpath expression /// </returns> /// <throws>EPException is there are XPath errors</throws> public static EventPropertyGetterSPI GetXPathResolution( string propertyName, XPathNamespaceContext xPathContext, string rootElementName, string @namespace, SchemaModel schemaModel, EventBeanTypedEventFactory eventBeanTypedEventFactory, BaseXMLEventType xmlEventType, bool isAllowFragment, string defaultNamespace) { if (Log.IsDebugEnabled) { Log.Debug("Determining XPath expression for property '" + propertyName + "'"); } var ctx = new XPathNamespaceContext(); var namespaces = schemaModel.Namespaces; string defaultNamespacePrefix = null; for (var i = 0; i < namespaces.Count; i++) { var namespacePrefix = "n" + i; ctx.AddNamespace(namespacePrefix, namespaces[i]); if (defaultNamespace != null && defaultNamespace == namespaces[i]) { defaultNamespacePrefix = namespacePrefix; } } var property = PropertyParser.ParseAndWalkLaxToSimple(propertyName); var isDynamic = property.IsDynamic; var rootComplexElement = SchemaUtil.FindRootElement(schemaModel, @namespace, rootElementName); var prefix = ctx.LookupPrefix(rootComplexElement.Namespace); if (prefix == null) { prefix = ""; } else { prefix += ':'; } var xPathBuf = new StringBuilder(); xPathBuf.Append('/'); xPathBuf.Append(prefix); if (rootElementName.StartsWith("//")) { xPathBuf.Append(rootElementName.Substring(2)); } else { xPathBuf.Append(rootElementName); } var parentComplexElement = rootComplexElement; Pair <string, XPathResultType> pair = null; if (!(property is NestedProperty)) { pair = MakeProperty(rootComplexElement, property, ctx, true, isDynamic, defaultNamespacePrefix); if (pair == null) { throw new PropertyAccessException("Failed to locate property '" + propertyName + "' in schema"); } xPathBuf.Append(pair.First); } else { var nestedProperty = (NestedProperty)property; var indexLast = nestedProperty.Properties.Count - 1; for (var i = 0; i < indexLast + 1; i++) { var isLast = i == indexLast; var propertyNested = nestedProperty.Properties[i]; pair = MakeProperty( parentComplexElement, propertyNested, ctx, isLast, isDynamic, defaultNamespacePrefix); if (pair == null) { throw new PropertyAccessException( "Failed to locate property '" + propertyName + "' nested property part '" + property.PropertyNameAtomic + "' in schema"); } var text = propertyNested.PropertyNameAtomic; var obj = SchemaUtil.FindPropertyMapping(parentComplexElement, text); if (obj is SchemaElementComplex) { parentComplexElement = (SchemaElementComplex)obj; } xPathBuf.Append(pair.First); } } var xPath = xPathBuf.ToString(); if (ExecutionPathDebugLog.IsDebugEnabled && Log.IsDebugEnabled) { Log.Debug(".parse XPath for property '" + propertyName + "' is expression=" + xPath); } // Compile assembled XPath expression if (Log.IsDebugEnabled) { Log.Debug( "Compiling XPath expression '" + xPath + "' for property '" + propertyName + "' using namespace context :" + ctx); } XPathExpression expr; try { expr = XPathExpression.Compile(xPath, ctx); } catch (XPathException e) { var detail = "Error constructing XPath expression from property expression '" + propertyName + "' expression '" + xPath + "'"; if (e.Message != null) { throw new EPException(detail + " :" + e.Message, e); } throw new EPException(detail, e); } // get type var item = property.GetPropertyTypeSchema(rootComplexElement); if (item == null && !isDynamic) { return(null); } var resultType = isDynamic ? typeof(XmlNode) : SchemaUtil.ToReturnType(item); FragmentFactory fragmentFactory = null; if (isAllowFragment) { fragmentFactory = new FragmentFactoryDOMGetter(eventBeanTypedEventFactory, xmlEventType, propertyName); } return(new XPathPropertyGetter( xmlEventType, propertyName, xPath, expr, pair.Second, resultType, fragmentFactory)); }
private static Pair <string, XPathResultType> MakeElementProperty( SchemaElement schemaElement, Property property, XPathNamespaceContext ctx, bool isAlone, bool isDynamic, string defaultNamespacePrefix) { XPathResultType type; if (isDynamic) { type = XPathResultType.Any; } else if (schemaElement is SchemaElementSimple) { var element = (SchemaElementSimple)schemaElement; type = SchemaUtil.SimpleTypeToResultType(element.SimpleType); } else { var complex = (SchemaElementComplex)schemaElement; type = XPathResultType.Any; //if (complex.OptionalSimpleType != null) //{ // type = SchemaUtil.SimpleTypeToQName(complex.OptionalSimpleType); //} //else //{ // // The result is a node // type = XPathResultType.Any; //} } var prefix = isDynamic ? defaultNamespacePrefix : ctx.LookupPrefix(schemaElement.Namespace); if (string.IsNullOrEmpty(prefix)) { prefix = string.Empty; } else { prefix += ':'; } if (IsAnySimpleProperty(property)) { if (!isDynamic && schemaElement.IsArray && !isAlone) { throw new PropertyAccessException( "Simple property not allowed in repeating elements at '" + schemaElement.Name + "'"); } return(new Pair <string, XPathResultType>('/' + prefix + property.PropertyNameAtomic, type)); } if (IsAnyMappedProperty(property)) { if (!isDynamic && !schemaElement.IsArray) { throw new PropertyAccessException( "Element " + property.PropertyNameAtomic + " is not a collection, cannot be used as mapped property"); } var key = GetMappedPropertyKey(property); return(new Pair <string, XPathResultType>( '/' + prefix + property.PropertyNameAtomic + "[@id='" + key + "']", type)); } if (!isDynamic && !schemaElement.IsArray) { throw new PropertyAccessException( "Element " + property.PropertyNameAtomic + " is not a collection, cannot be used as mapped property"); } var index = GetIndexedPropertyIndex(property); var xPathPosition = index + 1; return(new Pair <string, XPathResultType>( '/' + prefix + property.PropertyNameAtomic + "[position() = " + xPathPosition + ']', type)); }
public SchemaXMLEventType( EventTypeMetadata eventTypeMetadata, ConfigurationCommonEventTypeXMLDOM config, SchemaModel schemaModel, string representsFragmentOfProperty, string representsOriginalTypeName, EventBeanTypedEventFactory eventBeanTypedEventFactory, EventTypeNameResolver eventTypeResolver, XMLFragmentEventTypeFactory xmlEventTypeFactory) : base( eventTypeMetadata, config, eventBeanTypedEventFactory, eventTypeResolver, xmlEventTypeFactory) { propertyGetterCache = new Dictionary<string, EventPropertyGetterSPI>(); SchemaModel = schemaModel; rootElementNamespace = config.RootElementNamespace; schemaModelRoot = SchemaUtil.FindRootElement(schemaModel, rootElementNamespace, RootElementName); isPropertyExpressionXPath = config.IsXPathPropertyExpr; RepresentsFragmentOfProperty = representsFragmentOfProperty; RepresentsOriginalTypeName = representsOriginalTypeName; // Set of namespace context for XPath expressions var ctx = new XPathNamespaceContext(); if (config.DefaultNamespace != null) { ctx.SetDefaultNamespace(config.DefaultNamespace); } foreach (var entry in config.NamespacePrefixes) { ctx.AddNamespace(entry.Key, entry.Value); } NamespaceContext = ctx; // add properties for the root element IList<ExplicitPropertyDescriptor> additionalSchemaProps = new List<ExplicitPropertyDescriptor>(); // Add a property for each complex child element foreach (SchemaElementComplex complex in schemaModelRoot.ComplexElements) { var propertyName = complex.Name; var returnType = typeof(XmlNode); Type propertyComponentType = null; if (complex.OptionalSimpleType != null) { returnType = SchemaUtil.ToReturnType(complex); if (returnType == typeof(string)) { propertyComponentType = typeof(char); } } if (complex.IsArray) { returnType = typeof(XmlNode[]); // We use Node[] for arrays and NodeList for XPath-Expressions returning Nodeset propertyComponentType = typeof(XmlNode); } var isFragment = false; if (ConfigurationEventTypeXMLDOM.IsAutoFragment && !ConfigurationEventTypeXMLDOM.IsXPathPropertyExpr) { isFragment = CanFragment(complex); } var getter = DoResolvePropertyGetter(propertyName, true); var desc = new EventPropertyDescriptor( propertyName, returnType, propertyComponentType, false, false, complex.IsArray, false, isFragment); var @explicit = new ExplicitPropertyDescriptor(desc, getter, false, null); additionalSchemaProps.Add(@explicit); } // Add a property for each simple child element foreach (var simple in schemaModelRoot.SimpleElements) { var propertyName = simple.Name; var returnType = SchemaUtil.ToReturnType(simple); var componentType = GenericExtensions.GetComponentType(returnType); var isIndexed = simple.IsArray || componentType != null; var getter = DoResolvePropertyGetter(propertyName, true); var desc = new EventPropertyDescriptor( propertyName, returnType, componentType, false, false, isIndexed, false, false); var @explicit = new ExplicitPropertyDescriptor(desc, getter, false, null); additionalSchemaProps.Add(@explicit); } // Add a property for each attribute foreach (var attribute in schemaModelRoot.Attributes) { var propertyName = attribute.Name; var returnType = SchemaUtil.ToReturnType(attribute); var componentType = GenericExtensions.GetComponentType(returnType); var isIndexed = componentType != null; var getter = DoResolvePropertyGetter(propertyName, true); var desc = new EventPropertyDescriptor( propertyName, returnType, componentType, false, false, isIndexed, false, false); var @explicit = new ExplicitPropertyDescriptor(desc, getter, false, null); additionalSchemaProps.Add(@explicit); } // Finally add XPath properties as that may depend on the rootElementNamespace Initialize(config.XPathProperties.Values, additionalSchemaProps); }
private EventPropertyGetterSPI DoResolvePropertyGetter( string propertyExpression, bool allowSimpleProperties) { var getter = propertyGetterCache.Get(propertyExpression); if (getter != null) { return getter; } if (!allowSimpleProperties) { // see if this is an indexed property var index = StringValue.UnescapedIndexOfDot(propertyExpression); if (index == -1) { // parse, can be an indexed property var property = PropertyParser.ParseAndWalkLaxToSimple(propertyExpression); if (!property.IsDynamic) { if (!(property is IndexedProperty)) { return null; } var indexedProp = (IndexedProperty) property; getter = propertyGetters.Get(indexedProp.PropertyNameAtomic); if (null == getter) { return null; } var descriptor = PropertyDescriptorMap.Get(indexedProp.PropertyNameAtomic); if (descriptor == null) { return null; } if (!descriptor.IsIndexed) { return null; } if (descriptor.PropertyType == typeof(XmlNodeList)) { FragmentFactorySPI fragmentFactory = new FragmentFactoryDOMGetter( EventBeanTypedEventFactory, this, indexedProp.PropertyNameAtomic); return new XPathPropertyArrayItemGetter(getter, indexedProp.Index, fragmentFactory); } else if (descriptor.PropertyType == typeof(string)) { FragmentFactorySPI fragmentFactory = new FragmentFactoryDOMGetter( EventBeanTypedEventFactory, this, indexedProp.PropertyNameAtomic); return new XPathPropertyArrayItemGetter(getter, indexedProp.Index, fragmentFactory); } } } } if (!isPropertyExpressionXPath) { var prop = PropertyParser.ParseAndWalkLaxToSimple(propertyExpression); var isDynamic = prop.IsDynamic; if (!isDynamic) { var item = prop.GetPropertyTypeSchema(schemaModelRoot); if (item == null) { return null; } getter = prop.GetGetterDOM(schemaModelRoot, EventBeanTypedEventFactory, this, propertyExpression); if (getter == null) { return null; } var returnType = SchemaUtil.ToReturnType(item); if (returnType != typeof(XmlNode) && returnType != typeof(XmlNodeList)) { if (!returnType.IsArray) { getter = new DOMConvertingGetter((DOMPropertyGetter) getter, returnType); } else { getter = new DOMConvertingArrayGetter( (DOMPropertyGetter) getter, returnType.GetElementType()); } } } else { return prop.GetterDOM; } } else { var allowFragments = !ConfigurationEventTypeXMLDOM.IsXPathPropertyExpr; getter = SchemaXMLPropertyParser.GetXPathResolution( propertyExpression, NamespaceContext, RootElementName, rootElementNamespace, SchemaModel, EventBeanTypedEventFactory, this, allowFragments, ConfigurationEventTypeXMLDOM.DefaultNamespace); } propertyGetterCache.Put(propertyExpression, getter); return getter; }