Java JXPathContext.setLenient方法代码示例

import org.apache.commons.jxpath.JXPathContext; //导入方法依赖的package包/类
public static Object getAttribute(Object object, String key) {
  try {
    Object event = object;
    if (object instanceof String) {
      ObjectMapper mapper = new ObjectMapper();
      event = mapper.readValue(object.toString(), HashMap.class);
    }
    if (event != null) {
      JXPathContext context = JXPathContext.newContext(event);
      context.setLenient(true);
      return context.getValue(key);
    }
  }
  catch (Exception e) { // NOPMD
    return null;
  }
  return null;
}
 

import org.apache.commons.jxpath.JXPathContext; //导入方法依赖的package包/类
/**
 * Determine the product model flag value (decompress GZIP data and check for productModel entries)
 * 
 * @param data
 *            GZIP compressed data of XML
 * @return <code>true</code> if product models are available, <code>false</code> otherwise
 */
private boolean determineFlag( byte[] data ) {
	try {
		JDOMParser parser = new JDOMParser();
		parser.setValidating( false );
		Object doc = parser.parseXML( new GZIPInputStream( new ByteArrayInputStream( data ) ) );
		JXPathContext context = JXPathContext.newContext( doc );
		context.setLenient( true );
		context.registerNamespace( "common", "http://lca.jrc.it/ILCD/Common" );
		context.registerNamespace( "ilcd", "http://lca.jrc.it/ILCD/Process" );
		context.registerNamespace( "pm", "http://iai.kit.edu/ILCD/ProductModel" );

		DataSetParsingHelper helper = new DataSetParsingHelper( context );
		return helper.getElements( "/ilcd:processDataSet/ilcd:processInformation/common:other/pm:productModel" ).size() > 0;
	}
	catch ( Exception e ) {
		return false;
	}

}
 

import org.apache.commons.jxpath.JXPathContext; //导入方法依赖的package包/类
public static List<Object> findJaxbElementUsingJXPath(Object object, String xPath) {

        List<Object> listObjectFound = new ArrayList<Object>();

        JXPathContext context = JXPathContext.newContext(object);
        context.setLenient(true);
        Iterator<?> it = context.iterate(xPath);
        while (it.hasNext()) {
            listObjectFound.add(it.next());
        }
        return listObjectFound;
    }
 

import org.apache.commons.jxpath.JXPathContext; //导入方法依赖的package包/类
public <T> T evaluate(Exchange exchange, Class<T> tClass) {
    try {
        JXPathContext context = JXPathContext.newContext(exchange);
        context.setLenient(lenient);
        Object result = getJXPathExpression().getValue(context, type);
        assertResultType(exchange, result);
        return exchange.getContext().getTypeConverter().convertTo(tClass, result);
    } catch (JXPathException e) {
        throw new ExpressionEvaluationException(this, exchange, e);
    }
}
 

import org.apache.commons.jxpath.JXPathContext; //导入方法依赖的package包/类
public ObjectGraphNavigationResult navigateTo(final Object root, final String xpath) throws InvalidConfigurationException {
    Assert.argumentNotNull("root", root);
    Assert.argumentNotNull("xpath", xpath);

    try {
        final JXPathContext ctx = JXPathContext.newContext(root);
        ctx.setLenient(true); // do not throw an exception if object graph is incomplete, e.g. contains null-values

        Pointer pointer = ctx.getPointer(xpath);

        // no match found or invalid xpath
        if (pointer instanceof NullPropertyPointer || pointer instanceof NullPointer)
            return null;

        if (pointer instanceof BeanPointer) {
            final Pointer parent = ((BeanPointer) pointer).getImmediateParentPointer();
            if (parent instanceof PropertyPointer) {
                pointer = parent;
            }
        }

        if (pointer instanceof PropertyPointer) {
            final PropertyPointer pp = (PropertyPointer) pointer;
            final Class<?> beanClass = pp.getBean().getClass();
            AccessibleObject accessor = ReflectionUtils.getField(beanClass, pp.getPropertyName());
            if (accessor == null) {
                accessor = ReflectionUtils.getGetter(beanClass, pp.getPropertyName());
            }
            return new ObjectGraphNavigationResult(root, xpath, pp.getBean(), accessor, pointer.getValue());
        }

        throw new InvalidConfigurationException("Don't know how to handle pointer [" + pointer + "] of type [" + pointer.getClass().getName()
                + "] for xpath [" + xpath + "]");
    } catch (final JXPathNotFoundException ex) {
        // thrown if the xpath is invalid
        throw new InvalidConfigurationException(ex);
    }
}
 

import org.apache.commons.jxpath.JXPathContext; //导入方法依赖的package包/类
/**
 * transformToObject - This method converts incoming JsonString to HashMap. Need/use of this method is, in EPL we need
 * to use pass Objects through window. But EPL allows primitives type alone. For that we 'll convert Obejct to
 * JsonString and pass it to the stream. After that we need to convert back the Json String to original Object type.
 * 
 */
@SuppressWarnings("unchecked")
public static HashMap<String, Object> transformToObjectAndRemoveKey(String jsonStr, String key) throws Exception {
  if (jsonStr != null) {
    ObjectMapper mapper = new ObjectMapper();
    HashMap<String, Object> event = mapper.readValue(jsonStr, HashMap.class);
    if (key != null && !key.equals("")) {
      JXPathContext context = JXPathContext.newContext(event);
      context.setLenient(true);
      context.removePath(key);
    }
    return event;
  }
  return null;
}
 

import org.apache.commons.jxpath.JXPathContext; //导入方法依赖的package包/类
@Override
public void transfer(OutputStream out) {
	this.context.put("create", true);
	
	JXPathContext xPathContext = getXPathContext();
	xPathContext.setLenient(true);
	Object o = xPathContext.getValue(getPath());
	if (o != null) {
		throw new IllegalArgumentException("Path '" + getPath() + "' exists.");
	}
	setupTX();
	
	Pointer p = xPathContext.createPath(getPath());
	
	JXPathContext relContext = getRelativeContext(p);
	
	for (String outputAttribute : getInputAttributeNameAsArray()) {
		
		/*
		Iterator<Pointer> outputAttrPointersIter = context.iteratePointers(outputAttribute);
		while(outputAttrPointersIter.hasNext()) {
			Pointer vPointer = outputAttrPointersIter.next();
			Object values = getValues(outputAttribute);
			//NodePointer nP = (NodePointer)vPointer;
			//nP.getImmediateValuePointer().setValue(values);
			vPointer.setValue(values);
		}
		*/	
		Object values = getValues(outputAttribute);
		relContext.setValue(outputAttribute, values);
	}
	
	processTX();
}
 

import org.apache.commons.jxpath.JXPathContext; //导入方法依赖的package包/类
/**
 * Gives a message builder from the content provided.
 *
 * @param content - The content object that is converted to JXPathContext to build the message.
 * @return The corresponding message builder object for the input.
 */
public Message.Builder builder(final Object content) {
    JXPathContext jXPathContext = JXPathContext.newContext(content);
    jXPathContext.setLenient(true);
    JXPathCopier jxPathCopier = new JXPathCopier(jXPathContext, null);

    return transformUsing(new Context(context), builderConfig, jxPathCopier, transform);
}
 

import org.apache.commons.jxpath.JXPathContext; //导入方法依赖的package包/类
private DataSet parseStream( InputStream inputStream ) {

		JDOMParser parser = new JDOMParser();
		parser.setValidating( false );
		Object doc = parser.parseXML( inputStream );
		JXPathContext context = JXPathContext.newContext( doc );
		context.setLenient( true );
		context.registerNamespace( "common", "http://lca.jrc.it/ILCD/Common" );

		parserHelper = new DataSetParsingHelper( context );
		commonReader = new CommonConstructsReader( parserHelper );

		return parse( context, out );
	}
 

import org.apache.commons.jxpath.JXPathContext; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
@Override
public boolean apply(Object input) {
    JXPathContext jxpath = JXPathContext.newContext(input);
    // We should allow non-existing path, and let predicate handle it. 
    jxpath.setLenient(true);
    
    Object value = jxpath.getValue(xpath);
   
    return predicate.apply(value);
}
 

import org.apache.commons.jxpath.JXPathContext; //导入方法依赖的package包/类
@Override
public boolean apply(Object input) {
    JXPathContext jxpath = JXPathContext.newContext(input);
    // We should allow non-existing path, and let predicate handle it.
    jxpath.setLenient(true);

    Pointer pointer = jxpath.getPointer(xpath);
   
    return pointer != null && !(pointer instanceof NullPointer) && pointer.getValue() != null;
}
 

import org.apache.commons.jxpath.JXPathContext; //导入方法依赖的package包/类
@Override
  public boolean apply(@Nullable String input) {
JXPathContext context = JXPathContext.newContext(input);
context.setLenient(true);
   return Objects.equal(context.getValue(valueXpath), context.getValue(inputXpath));
  }