public Object getDirectValue(Object staticContext, VariableResolverFactory factory) { return execute(false, this, staticContext, importInjectionRequired ? new ClassImportResolverFactory(parserConfiguration, factory, true) : new StackResetResolverFactory(factory)); }
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) { if (!packageImport) { return findClassImportResolverFactory(factory).addClass(importClass); } else { findClassImportResolverFactory(factory).addPackageImport(new String(name, 0, (int) offset)); return null; } }
public static Map<String, Object> getInjectedImports(VariableResolverFactory factory) { if (factory == null) return null; do { if (factory instanceof ClassImportResolverFactory) { return ((ClassImportResolverFactory) factory).getImportedClasses(); } } while ((factory = factory.getNextFactory()) != null); return null; }
public boolean isResolveable(String name) { if (variableResolvers.containsKey(name) || isNextResolveable(name)) { return true; } else if (packageImports != null) { for (String s : packageImports) { try { addClass(classLoader.loadClass(s + "." + name)); return true; } catch (ClassNotFoundException e) { // do nothing; } catch (NoClassDefFoundError e) { // do nothing; } } } return false; }
public void testCheeseConstructor() { MapVariableResolverFactory mvf = new MapVariableResolverFactory(createTestMap()); ClassImportResolverFactory classes = new ClassImportResolverFactory(null, null, false); classes.addClass(Cheese.class); ResolverTools.appendFactory(mvf, classes); assertTrue(executeExpression(compileExpression("cheese = new Cheese(\"cheddar\", 15);", classes.getImportedClasses()), mvf) instanceof Cheese); }
@Override public VariableResolver getVariableResolver(String name) { if (isResolveable(name)) { if (imports != null && imports.containsKey(name)) { return new SimpleValueResolver(imports.get(name)); } else if (dynImports != null && dynImports.containsKey(name)) { return new SimpleValueResolver(dynImports.get(name)); } else if (nextFactory != null) { return nextFactory.getVariableResolver(name); } } throw new UnresolveablePropertyException("unable to resolve variable '" + name + "'"); }
protected Class getImport(String name) { if (pCtx == null) pCtx = getParserContext(); if (pCtx.hasImport(name)) return pCtx.getImport(name); return (Class) findClassImportResolverFactory(variableFactory).getVariableResolver(name).getValue(); } }
public void testSataticClassImportViaFactoryAndWithModification() { OptimizerFactory.setDefaultOptimizer("ASM"); MapVariableResolverFactory mvf = new MapVariableResolverFactory(createTestMap()); ClassImportResolverFactory classes = new ClassImportResolverFactory(null, null, false); classes.addClass(Person.class); ResolverTools.appendFactory(mvf, classes); assertEquals(21, executeExpression( compileExpression("p = new Person('tom'); p.age = 20; " + "with( p ) { age = p.age + 1 }; return p.age;", classes.getImportedClasses()), mvf)); }
public boolean isResolveable(String name) { if (name == null) return false; if ((imports != null && imports.containsKey(name)) || (dynImports != null && dynImports.containsKey(name)) || isNextResolveable(name)) { return true; } else if (packageImports != null) { for (String s : packageImports) { try { addClass(classLoader.loadClass(s + "." + name)); return true; } catch (ClassNotFoundException e) { // do nothing; } catch (NoClassDefFoundError e) { // do nothing; } } } return false; }
@Override public VariableResolver getVariableResolver(String name) { if (isResolveable(name)) { if (imports != null && imports.containsKey(name)) { return new SimpleValueResolver(imports.get(name)); } else if (dynImports != null && dynImports.containsKey(name)) { return new SimpleValueResolver(dynImports.get(name)); } else if (nextFactory != null) { return nextFactory.getVariableResolver(name); } } throw new UnresolveablePropertyException("unable to resolve variable '" + name + "'"); }
public Object getDirectValue(Object staticContext, VariableResolverFactory factory) { return execute(false, this, staticContext, importInjectionRequired ? new ClassImportResolverFactory(parserConfiguration, factory, true) : new StackResetResolverFactory(factory)); }
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) { if (!packageImport) { if (MVEL.COMPILER_OPT_ALLOCATE_TYPE_LITERALS_TO_SHARED_SYMBOL_TABLE) { factory.createVariable(importClass.getSimpleName(), importClass); return importClass; } return findClassImportResolverFactory(factory, pCtx).addClass(importClass); } // if the factory is an ImmutableDefaultFactory it means this import is unused so we can skip it safely if (!(factory instanceof ImmutableDefaultFactory) && !(factory instanceof StackResetResolverFactory && ((StackResetResolverFactory) factory).getDelegate() instanceof ImmutableDefaultFactory)) { findClassImportResolverFactory(factory, pCtx).addPackageImport(new String(expr, start, _offset - start)); } return null; }
public boolean isResolveable(String name) { if (name == null) return false; if ((imports != null && imports.containsKey(name)) || (dynImports != null && dynImports.containsKey(name)) || isNextResolveable(name)) { return true; } else if (packageImports != null) { for (String s : packageImports) { try { addClass(classLoader.loadClass(s + "." + name)); return true; } catch (ClassNotFoundException e) { // do nothing; } catch (NoClassDefFoundError e) { // do nothing; } } } return false; }
public static Map<String, Object> getInjectedImports(VariableResolverFactory factory) { if (factory == null) return null; do { if (factory instanceof ClassImportResolverFactory) { return ((ClassImportResolverFactory) factory).getImportedClasses(); } } while ((factory = factory.getNextFactory()) != null); return null; }
public static ClassImportResolverFactory findClassImportResolverFactory(VariableResolverFactory factory, ParserContext pCtx) { if (factory == null) { throw new OptimizationFailure("unable to import classes. no variable resolver factory available."); } for (VariableResolverFactory v = factory; v != null; v = v.getNextFactory()) { if (v instanceof ClassImportResolverFactory) { return (ClassImportResolverFactory) v; } } return appendFactory(factory, new ClassImportResolverFactory(null, null, false)); }
public Object getReducedValueAccelerated(Object ctx, Object thisValue, VariableResolverFactory factory) { if (!packageImport) { if (MVEL.COMPILER_OPT_ALLOCATE_TYPE_LITERALS_TO_SHARED_SYMBOL_TABLE) { factory.createVariable(importClass.getSimpleName(), importClass); return importClass; } return findClassImportResolverFactory(factory, pCtx).addClass(importClass); } // if the factory is an ImmutableDefaultFactory it means this import is unused so we can skip it safely if (!(factory instanceof ImmutableDefaultFactory) && !(factory instanceof StackResetResolverFactory && ((StackResetResolverFactory) factory).getDelegate() instanceof ImmutableDefaultFactory)) { findClassImportResolverFactory(factory, pCtx).addPackageImport(new String(expr, start, _offset - start)); } return null; }
public static Map<String, Object> getInjectedImports(VariableResolverFactory factory) { if (factory == null) return null; do { if (factory instanceof ClassImportResolverFactory) { return ((ClassImportResolverFactory) factory).getImportedClasses(); } } while ((factory = factory.getNextFactory()) != null); return null; }
public Object getDirectValue(Object staticContext, VariableResolverFactory factory) { if (importInjectionRequired) { return execute(false, this, staticContext, new ClassImportResolverFactory(parserContext.getParserConfiguration(), factory)); } else { return execute(false, this, staticContext, factory); } }
public static ClassImportResolverFactory findClassImportResolverFactory(VariableResolverFactory factory, ParserContext pCtx) { if (factory == null) { throw new OptimizationFailure("unable to import classes. no variable resolver factory available."); } for (VariableResolverFactory v = factory; v != null; v = v.getNextFactory()) { if (v instanceof ClassImportResolverFactory) { return (ClassImportResolverFactory) v; } } return appendFactory(factory, new ClassImportResolverFactory(null, null, false)); }
public static Object executeDebugger(CompiledExpression expression, Object ctx, VariableResolverFactory vars) { if (expression.isImportInjectionRequired()) { return execute(true, expression, ctx, new ClassImportResolverFactory(expression.getParserConfiguration(), vars, false)); } else { return execute(true, expression, ctx, vars); } }