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));
}
