public XPathPropertyGetterCodegenFieldSharable( BaseXMLEventType baseXMLEventType, XPathPropertyGetter xPathPropertyGetter) { this.baseXMLEventType = baseXMLEventType; this.xPathPropertyGetter = xPathPropertyGetter; }
/// <summary> /// Ctor. /// </summary> /// <param name="eventBeanTypedEventFactory">for event type lookup</param> /// <param name="xmlEventType">the originating type</param> /// <param name="propertyExpression">property expression</param> public FragmentFactoryDOMGetter( EventBeanTypedEventFactory eventBeanTypedEventFactory, BaseXMLEventType xmlEventType, string propertyExpression) { this.eventBeanTypedEventFactory = eventBeanTypedEventFactory; this.xmlEventType = xmlEventType; this.propertyExpression = propertyExpression; }
/// <summary> /// Ctor. /// </summary> /// <param name="runtimeEventSender">for processing events</param> /// <param name="baseXMLEventType">the event type</param> /// <param name="threadingService">for inbound threading</param> /// <param name="eventBeanTypedEventFactory">for event bean creation</param> public EventSenderXMLDOM( EPRuntimeEventProcessWrapped runtimeEventSender, BaseXMLEventType baseXMLEventType, EventBeanTypedEventFactory eventBeanTypedEventFactory, ThreadingCommon threadingService) { this.runtimeEventSender = runtimeEventSender; this.baseXMLEventType = baseXMLEventType; validateRootElement = baseXMLEventType.ConfigurationEventTypeXMLDOM.IsEventSenderValidatesRoot; this.eventBeanTypedEventFactory = eventBeanTypedEventFactory; this.threadingService = threadingService; }
public static EventPropertyGetterSPI ResolveSimpleXMLPropertyGetter( string propertyExpression, BaseXMLEventType baseXMLEventType, string defaultNamespacePrefix, bool isResolvePropertiesAbsolute) { if (!baseXMLEventType.ConfigurationEventTypeXMLDOM.IsXPathPropertyExpr) { var prop = PropertyParser.ParseAndWalkLaxToSimple(propertyExpression); var getter = prop.GetterDOM; if (!prop.IsDynamic) { getter = new DOMConvertingGetter((DOMPropertyGetter) getter, typeof(string)); } return getter; } try { var property = PropertyParserNoDep.ParseAndWalkLaxToSimple(propertyExpression, false); var isDynamic = PropertyParser.IsPropertyDynamic(property); var xPathExpr = SimpleXMLPropertyParser.Walk( property, baseXMLEventType.RootElementName, defaultNamespacePrefix, isResolvePropertiesAbsolute); if (Log.IsInfoEnabled) { Log.Info( "Compiling XPath expression for property '" + propertyExpression + "' as '" + xPathExpr + "'"); } var xPathExpression = baseXMLEventType.CreateXPath(xPathExpr); var xPathReturnType = isDynamic ? XPathResultType.Any : XPathResultType.String; return new XPathPropertyGetter( baseXMLEventType, propertyExpression, xPathExpr, xPathExpression, xPathReturnType, null, null); } catch (XPathException e) { throw new EPException( "Error constructing XPath expression from property name '" + propertyExpression + '\'', e); } }
public XPathPropertyGetter( BaseXMLEventType baseXMLEventType, string propertyName, string expressionText, XPathExpression xPathExpression, XPathResultType resultType, Type optionalCastToType, FragmentFactory fragmentFactory) { _expression = xPathExpression; _expressionText = expressionText; _property = propertyName; _resultType = resultType; _fragmentFactory = fragmentFactory; _baseXMLEventType = baseXMLEventType; if (optionalCastToType != null && optionalCastToType.IsArray) { _isCastToArray = true; if (resultType != XPathResultType.NodeSet) { throw new ArgumentException( "Array cast-to types require XPathResultType.NodeSet as the XPath result type"); } optionalCastToType = optionalCastToType.GetElementType(); } else { _isCastToArray = false; } if (optionalCastToType != null) { _simpleTypeParser = SimpleTypeParserFactory.GetParser(optionalCastToType); } else { _simpleTypeParser = null; } if (optionalCastToType == typeof(XmlNode)) { this._optionalCastToType = null; } else { this._optionalCastToType = optionalCastToType; } }
/// <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)); }