private Type DoResolvePropertyType(String propertyExpression, bool allowSimpleProperties) { // see if this is an indexed property int index = ASTUtil.UnescapedIndexOfDot(propertyExpression); if ((!allowSimpleProperties) && (index == -1)) { // parse, can be an indexed property Property property = PropertyParser.ParseAndWalkLaxToSimple(propertyExpression); if (!property.IsDynamic) { if (!(property is IndexedProperty)) { return(null); } var indexedProp = (IndexedProperty)property; EventPropertyDescriptor descriptor = PropertyDescriptorMap.Get(indexedProp.PropertyNameAtomic); if (descriptor == null) { return(null); } return(descriptor.PropertyType); } } Property prop = PropertyParser.ParseAndWalkLaxToSimple(propertyExpression); if (prop.IsDynamic) { return(typeof(XmlNode)); } SchemaItem item = prop.GetPropertyTypeSchema(_schemaModelRoot, EventAdapterService); if (item == null) { return(null); } return(SchemaUtil.ToReturnType(item)); }
/// <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="eventAdapterService">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 EventPropertyGetter GetXPathResolution(String propertyName, XPathNamespaceContext xPathContext, String rootElementName, String @namespace, SchemaModel schemaModel, EventAdapterService eventAdapterService, 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 (int i = 0; i < namespaces.Count; i++) { var namespacePrefix = "n" + i; ctx.AddNamespace(namespacePrefix, namespaces[i]); if ((defaultNamespace != null) && (defaultNamespace == namespaces[i])) { defaultNamespacePrefix = namespacePrefix; } } Property property = PropertyParser.ParseAndWalk(propertyName); var isDynamic = property.IsDynamic; var rootComplexElement = SchemaUtil.FindRootElement(schemaModel, @namespace, rootElementName); string 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 { NestedProperty nestedProperty = (NestedProperty)property; int indexLast = nestedProperty.Properties.Count - 1; for (int 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.IsEnabled) && (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) { String 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, eventAdapterService); if ((item == null) && (!isDynamic)) { return(null); } var resultType = isDynamic ? typeof(XmlNode) : SchemaUtil.ToReturnType(item); FragmentFactory fragmentFactory = null; if (isAllowFragment) { fragmentFactory = new FragmentFactoryDOMGetter(eventAdapterService, xmlEventType, propertyName); } return(new XPathPropertyGetter(propertyName, xPath, expr, pair.Second, resultType, fragmentFactory)); }
/// <summary> /// Set the preconfigured event properties resolved by XPath expression. /// </summary> /// <param name="explicitXPathProperties">are preconfigured event properties</param> /// <param name="additionalSchemaProperties">the explicit properties</param> protected void Initialize(ICollection <ConfigurationEventTypeXMLDOM.XPathPropertyDesc> explicitXPathProperties, IList <ExplicitPropertyDescriptor> additionalSchemaProperties) { // make sure we override those explicitly provided with those derived from a metadataz var namedProperties = new LinkedHashMap <String, ExplicitPropertyDescriptor>(); foreach (ExplicitPropertyDescriptor desc in additionalSchemaProperties) { namedProperties[desc.Descriptor.PropertyName] = desc; } String xPathExpression = null; try { foreach (ConfigurationEventTypeXMLDOM.XPathPropertyDesc property in explicitXPathProperties) { xPathExpression = property.XPath; if (Log.IsInfoEnabled) { Log.Info("Compiling XPath expression for property '" + property.Name + "' as '" + xPathExpression + "'"); } var expressionContext = NamespaceContext ?? GetExtendedContext(); var expression = XPathExpression.Compile(xPathExpression, expressionContext); FragmentFactoryXPathPredefinedGetter fragmentFactory = null; var isFragment = false; if (property.OptionalEventTypeName != null) { fragmentFactory = new FragmentFactoryXPathPredefinedGetter( EventAdapterService, property.OptionalEventTypeName, property.Name); isFragment = true; } var getter = new XPathPropertyGetter( property.Name, xPathExpression, expression, property.ResultType, property.OptionalCastToType, fragmentFactory); var returnType = SchemaUtil.ToReturnType( property.ResultType, property.OptionalCastToType.GetBoxedType()); var indexType = returnType.GetIndexType(); var isIndexed = indexType != null; if (property.ResultType == XPathResultType.NodeSet) { isIndexed = true; } var desc = new EventPropertyDescriptor( property.Name, returnType, indexType, false, false, isIndexed, false, isFragment); var @explicit = new ExplicitPropertyDescriptor( desc, getter, isIndexed, property.OptionalEventTypeName); namedProperties[desc.PropertyName] = @explicit; } } catch (XPathException ex) { throw new EPException( "XPath expression could not be compiled for expression '" + xPathExpression + '\'', ex); } Initialize(namedProperties.Values); // evaluate start and end timestamp properties if any _startTimestampPropertyName = ConfigurationEventTypeXMLDOM.StartTimestampPropertyName; _endTimestampPropertyName = ConfigurationEventTypeXMLDOM.EndTimestampPropertyName; EventTypeUtility.ValidateTimestampProperties(this, _startTimestampPropertyName, _endTimestampPropertyName); }
/// <summary> /// Ctor. /// </summary> /// <param name="eventTypeMetadata">event type metadata</param> /// <param name="eventTypeId">The event type id.</param> /// <param name="config">configuration for type</param> /// <param name="schemaModel">the schema representation</param> /// <param name="eventAdapterService">type lookup and registration</param> public SchemaXMLEventType(EventTypeMetadata eventTypeMetadata, int eventTypeId, ConfigurationEventTypeXMLDOM config, SchemaModel schemaModel, EventAdapterService eventAdapterService) : base(eventTypeMetadata, eventTypeId, config, eventAdapterService) { _propertyGetterCache = new Dictionary <String, EventPropertyGetter>(); _schemaModel = schemaModel; _rootElementNamespace = config.RootElementNamespace; _schemaModelRoot = SchemaUtil.FindRootElement(schemaModel, _rootElementNamespace, RootElementName); _isPropertyExpressionXPath = config.IsXPathPropertyExpr; // 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 var 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 (complex.IsArray) { // We use XmlNode[] for arrays and NodeList for XPath-Expressions returning Nodeset returnType = typeof(XmlNode[]); propertyComponentType = typeof(XmlNode); } bool isFragment = false; if (ConfigurationEventTypeXMLDOM.IsAutoFragment && (!ConfigurationEventTypeXMLDOM.IsXPathPropertyExpr)) { isFragment = CanFragment(complex); } var indexType = returnType.GetIndexType(); var isIndexed = indexType != null; var getter = DoResolvePropertyGetter(propertyName, true); var desc = new EventPropertyDescriptor(propertyName, returnType, indexType, false, false, isIndexed, false, isFragment); var @explicit = new ExplicitPropertyDescriptor(desc, getter, false, null); additionalSchemaProps.Add(@explicit); } // Add a property for each simple child element foreach (SchemaElementSimple simple in _schemaModelRoot.SimpleElements) { var propertyName = simple.Name; var returnType = SchemaUtil.ToReturnType(simple); var getter = DoResolvePropertyGetter(propertyName, true); var indexType = returnType.GetIndexType(); var isIndexed = indexType != null; var desc = new EventPropertyDescriptor(propertyName, returnType, indexType, false, false, isIndexed, false, false); var @explicit = new ExplicitPropertyDescriptor(desc, getter, false, null); additionalSchemaProps.Add(@explicit); } // Add a property for each attribute foreach (SchemaItemAttribute attribute in _schemaModelRoot.Attributes) { var propertyName = attribute.Name; var returnType = SchemaUtil.ToReturnType(attribute); var getter = DoResolvePropertyGetter(propertyName, true); var indexType = returnType.GetIndexType(); var isIndexed = indexType != null; var desc = new EventPropertyDescriptor(propertyName, returnType, indexType, 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 EventPropertyGetter DoResolvePropertyGetter(String propertyExpression, bool allowSimpleProperties) { EventPropertyGetter getter = _propertyGetterCache.Get(propertyExpression); if (getter != null) { return(getter); } if (!allowSimpleProperties) { // see if this is an indexed property int index = ASTUtil.UnescapedIndexOfDot(propertyExpression); if (index == -1) { // parse, can be an indexed property Property 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); } EventPropertyDescriptor descriptor = PropertyDescriptorMap.Get(indexedProp.PropertyNameAtomic); if (descriptor == null) { return(null); } if (!descriptor.IsIndexed) { return(null); } if (descriptor.PropertyType == typeof(XmlNodeList)) { FragmentFactory fragmentFactory = new FragmentFactoryDOMGetter( EventAdapterService, this, indexedProp.PropertyNameAtomic); return(new XPathPropertyArrayItemGetter(getter, indexedProp.Index, fragmentFactory)); } if (descriptor.PropertyType == typeof(string)) { FragmentFactory fragmentFactory = new FragmentFactoryDOMGetter( EventAdapterService, this, indexedProp.PropertyNameAtomic); return(new XPathPropertyArrayItemGetter(getter, indexedProp.Index, fragmentFactory)); } } } } if (!_isPropertyExpressionXPath) { Property prop = PropertyParser.ParseAndWalkLaxToSimple(propertyExpression); bool isDynamic = prop.IsDynamic; if (!isDynamic) { SchemaItem item = prop.GetPropertyTypeSchema(_schemaModelRoot, EventAdapterService); if (item == null) { return(null); } getter = prop.GetGetterDOM(_schemaModelRoot, EventAdapterService, this, propertyExpression); if (getter == null) { return(null); } Type returnType = SchemaUtil.ToReturnType(item); if ((returnType != typeof(XmlNode)) && (returnType != typeof(XmlNodeList))) { if (!returnType.IsArray) { getter = new DOMConvertingGetter(propertyExpression, (DOMPropertyGetter)getter, returnType); } else { getter = new DOMConvertingArrayGetter((DOMPropertyGetter)getter, returnType.GetElementType()); } } } else { return(prop.GetGetterDOM()); } } else { bool allowFragments = !ConfigurationEventTypeXMLDOM.IsXPathPropertyExpr; getter = SchemaXMLPropertyParser.GetXPathResolution( propertyExpression, NamespaceContext, RootElementName, _rootElementNamespace, _schemaModel, EventAdapterService, this, allowFragments, ConfigurationEventTypeXMLDOM.DefaultNamespace); } _propertyGetterCache.Put(propertyExpression, getter); return(getter); }