Examples with And org.mvel2.ast.And used on opensource projects

Example 61 with And

use of org.mvel2.ast.And in project drools by kiegroup.

the class ClassGenerator method generateBytecode.

public byte[] generateBytecode() {
    if (bytecode == null) {
        ClassWriter cw = createClassWriter(classLoader, access, getClassDescriptor(), signature, getSuperClassDescriptor(), toInteralNames(interfaces));
        for (int i = 0; i < classParts.size(); i++) {
            // don't use iterator to allow method visits to add more class fields and methods
            classParts.get(i).write(this, cw);
        }
        if (staticInitializer != null) {
            staticInitializer.write(this, cw);
        }
        cw.visitEnd();
        bytecode = cw.toByteArray();
        if (DUMP_GENERATED_CLASSES) {
            dumpGeneratedClass(bytecode);
        }
    }
    return bytecode;
}

Example 62 with And

use of org.mvel2.ast.And in project drools-wb by kiegroup.

the class WorkDefinitionsParser method parse.

/**
 * Parse a MVEL String into WorkDefinitions
 * @param workItemDefinitions
 * @return
 */
@SuppressWarnings({ "unchecked", "rawtypes" })
public static Map<String, WorkDefinition> parse(final List<String> workItemDefinitions) {
    final Map<String, WorkDefinition> workDefinitions = new HashMap<String, WorkDefinition>();
    // Add Data-type imports, in-case they are missing from definition
    final ParserContext context = new ParserContext();
    // Compile expression and convert String
    for (String workItemDefinition : workItemDefinitions) {
        final List<Map<String, Object>> workDefinitionsMap = (List<Map<String, Object>>) WidMVELEvaluator.eval(workItemDefinition);
        // Populate model
        if (workDefinitionsMap != null) {
            for (Map<String, Object> workDefinitionMap : workDefinitionsMap) {
                if (workDefinitionMap != null) {
                    final WorkDefinitionImpl workDefinition = new WorkDefinitionImpl();
                    workDefinition.setName((String) workDefinitionMap.get("name"));
                    workDefinition.setDisplayName((String) workDefinitionMap.get("displayName"));
                    workDefinition.setIcon((String) workDefinitionMap.get("icon"));
                    workDefinition.setCustomEditor((String) workDefinitionMap.get("customEditor"));
                    final Set<ParameterDefinition> parameters = new HashSet<ParameterDefinition>();
                    if (workDefinitionMap.get("parameters") != null) {
                        final Map<String, DataType> parameterMap = (Map<String, DataType>) workDefinitionMap.get("parameters");
                        if (parameterMap != null) {
                            for (Map.Entry<String, DataType> entry : parameterMap.entrySet()) {
                                parameters.add(new ParameterDefinitionImpl(entry.getKey(), entry.getValue()));
                            }
                        }
                        workDefinition.setParameters(parameters);
                    }
                    if (workDefinitionMap.get("parameterValues") != null) {
                        workDefinition.setParameterValues((Map<String, Object>) workDefinitionMap.get("parameterValues"));
                    }
                    if (workDefinitionMap.get("results") != null) {
                        final Set<ParameterDefinition> results = new HashSet<ParameterDefinition>();
                        final Map<String, DataType> resultMap = (Map<String, DataType>) workDefinitionMap.get("results");
                        if (resultMap != null) {
                            for (Map.Entry<String, DataType> entry : resultMap.entrySet()) {
                                results.add(new ParameterDefinitionImpl(entry.getKey(), entry.getValue()));
                            }
                        }
                        workDefinition.setResults(results);
                    }
                    if (workDefinitionMap.get("defaultHandler") != null) {
                        workDefinition.setDefaultHandler((String) workDefinitionMap.get("defaultHandler"));
                    }
                    if (workDefinitionMap.get("dependencies") != null) {
                        workDefinition.setDependencies(((List<String>) workDefinitionMap.get("dependencies")).toArray(new String[0]));
                    }
                    if (workDefinitionMap.get("documentation") != null) {
                        workDefinition.setDocumentation((String) workDefinitionMap.get("documentation"));
                    }
                    if (workDefinitionMap.get("version") != null) {
                        workDefinition.setVersion((String) workDefinitionMap.get("version"));
                    }
                    if (workDefinitionMap.get("description") != null) {
                        workDefinition.setDescription((String) workDefinitionMap.get("description"));
                    }
                    if (workDefinitionMap.get("mavenDependencies") != null) {
                        workDefinition.setMavenDependencies(((List<String>) workDefinitionMap.get("mavenDependencies")).toArray(new String[0]));
                    }
                    workDefinitions.put(workDefinition.getName(), workDefinition);
                }
            }
        }
    }
    return workDefinitions;
}

Example 63 with And

use of org.mvel2.ast.And in project camel by apache.

the class MvelEndpoint method onExchange.

@Override
protected void onExchange(Exchange exchange) throws Exception {
    String path = getResourceUri();
    ObjectHelper.notNull(path, "resourceUri");
    String newResourceUri = exchange.getIn().getHeader(MvelConstants.MVEL_RESOURCE_URI, String.class);
    if (newResourceUri != null) {
        exchange.getIn().removeHeader(MvelConstants.MVEL_RESOURCE_URI);
        log.debug("{} set to {} creating new endpoint to handle exchange", MvelConstants.MVEL_RESOURCE_URI, newResourceUri);
        MvelEndpoint newEndpoint = findOrCreateEndpoint(getEndpointUri(), newResourceUri);
        newEndpoint.onExchange(exchange);
        return;
    }
    CompiledTemplate compiled;
    ParserContext mvelContext = ParserContext.create();
    Map<String, Object> variableMap = ExchangeHelper.createVariableMap(exchange);
    String content = exchange.getIn().getHeader(MvelConstants.MVEL_TEMPLATE, String.class);
    if (content != null) {
        // use content from header
        if (log.isDebugEnabled()) {
            log.debug("Mvel content read from header {} for endpoint {}", MvelConstants.MVEL_TEMPLATE, getEndpointUri());
        }
        // remove the header to avoid it being propagated in the routing
        exchange.getIn().removeHeader(MvelConstants.MVEL_TEMPLATE);
        compiled = TemplateCompiler.compileTemplate(content, mvelContext);
    } else {
        if (log.isDebugEnabled()) {
            log.debug("Mvel content read from resource {} with resourceUri: {} for endpoint {}", new Object[] { getResourceUri(), path, getEndpointUri() });
        }
        // getResourceAsInputStream also considers the content cache
        Reader reader = getEncoding() != null ? new InputStreamReader(getResourceAsInputStream(), getEncoding()) : new InputStreamReader(getResourceAsInputStream());
        String template = IOConverter.toString(reader);
        if (!template.equals(this.template)) {
            this.template = template;
            this.compiled = TemplateCompiler.compileTemplate(template, mvelContext);
        }
        compiled = this.compiled;
    }
    // let mvel parse and execute the template
    log.debug("Mvel is evaluating using mvel context: {}", variableMap);
    Object result = TemplateRuntime.execute(compiled, mvelContext, variableMap);
    // now lets output the results to the exchange
    Message out = exchange.getOut();
    out.setBody(result.toString());
    out.setHeaders(exchange.getIn().getHeaders());
    out.setAttachments(exchange.getIn().getAttachments());
}

Example 64 with And

use of org.mvel2.ast.And in project BroadleafCommerce by BroadleafCommerce.

the class MvelHelper method evaluateRule.

/**
 * @param rule
 * @param ruleParameters
 * @param expressionCache
 * @param additionalContextImports additional imports to give to the {@link ParserContext} besides "MVEL" ({@link MVEL} and
 * "MvelHelper" ({@link MvelHelper}) since they are automatically added
 * @return
 */
public static boolean evaluateRule(String rule, Map<String, Object> ruleParameters, Map<String, Serializable> expressionCache, Map<String, Class<?>> additionalContextImports) {
    // Null or empty is a match
    if (rule == null || "".equals(rule)) {
        return true;
    } else {
        // MVEL expression compiling can be expensive so let's cache the expression
        Serializable exp = null;
        if (expressionCache != null) {
            exp = expressionCache.get(rule);
        }
        if (exp == null) {
            ParserContext context = new ParserContext();
            context.addImport("MVEL", MVEL.class);
            context.addImport("MvelHelper", MvelHelper.class);
            context.addImport("CollectionUtils", SelectizeCollectionUtils.class);
            if (MapUtils.isNotEmpty(additionalContextImports)) {
                for (Entry<String, Class<?>> entry : additionalContextImports.entrySet()) {
                    context.addImport(entry.getKey(), entry.getValue());
                }
            }
            String modifiedRule = modifyExpression(rule, ruleParameters, context);
            synchronized (expressionCache) {
                exp = MVEL.compileExpression(modifiedRule, context);
                expressionCache.put(rule, exp);
            }
        }
        Map<String, Object> mvelParameters = new HashMap<String, Object>();
        if (ruleParameters != null) {
            for (String parameter : ruleParameters.keySet()) {
                mvelParameters.put(parameter, ruleParameters.get(parameter));
            }
        }
        try {
            Object test = MVEL.executeExpression(exp, mvelParameters);
            if (test == null) {
                // This can occur if there is no actual rule
                return true;
            }
            return (Boolean) test;
        } catch (Exception e) {
            // Return false, but notify about the bad expression through logs
            if (!TEST_MODE && LOG.isInfoEnabled()) {
                LOG.info("Unable to parse and/or execute the mvel expression (" + StringUtil.sanitize(rule) + "). Reporting to the logs and returning false for the match expression", e);
            }
            return false;
        }
    }
}

Example 65 with And

use of org.mvel2.ast.And in project mvel by mikebrock.

the class PropertyAccessor method getMethod.

/**
 * Find an appropriate method, execute it, and return it's response.
 *
 * @param ctx  -
 * @param name -
 * @return -
 * @throws Exception -
 */
@SuppressWarnings({ "unchecked" })
private Object getMethod(Object ctx, String name) {
    int _start = cursor;
    String tk = cursor != end && property[cursor] == '(' && ((cursor = balancedCapture(property, cursor, '(')) - _start) > 1 ? new String(property, _start + 1, cursor - _start - 1) : "";
    cursor++;
    Object[] args;
    if (tk.length() == 0) {
        args = ParseTools.EMPTY_OBJ_ARR;
    } else {
        List<char[]> subtokens = parseParameterList(tk.toCharArray(), 0, -1);
        args = new Object[subtokens.size()];
        for (int i = 0; i < subtokens.size(); i++) {
            args[i] = eval(subtokens.get(i), thisReference, variableFactory);
        }
    }
    if (first && variableFactory != null && variableFactory.isResolveable(name)) {
        Object ptr = variableFactory.getVariableResolver(name).getValue();
        if (ptr instanceof Method) {
            ctx = ((Method) ptr).getDeclaringClass();
            name = ((Method) ptr).getName();
        } else if (ptr instanceof MethodStub) {
            ctx = ((MethodStub) ptr).getClassReference();
            name = ((MethodStub) ptr).getMethodName();
        } else if (ptr instanceof Function) {
            ((Function) ptr).checkArgumentCount(args.length);
            return ((Function) ptr).call(null, thisReference, variableFactory, args);
        } else {
            throw new OptimizationFailure("attempt to optimize a method call for a reference that does not point to a method: " + name + " (reference is type: " + (ctx != null ? ctx.getClass().getName() : null) + ")");
        }
        first = false;
    }
    if (ctx == null)
        throw new CompileException("no such method or function: " + name, property, cursor);
    /**
     * If the target object is an instance of java.lang.Class itself then do not
     * adjust the Class scope target.
     */
    Class cls = (ctx instanceof Class ? (Class) ctx : ctx.getClass());
    if (cls == Proto.ProtoInstance.class) {
        return ((Proto.ProtoInstance) ctx).get(name).call(null, thisReference, variableFactory, args);
    }
    /**
     * Check to see if we have already cached this method;
     */
    Object[] cache = checkMethodCache(cls, createSignature(name, tk));
    Method m;
    Class[] parameterTypes;
    if (cache != null) {
        m = (Method) cache[0];
        parameterTypes = (Class[]) cache[1];
    } else {
        m = null;
        parameterTypes = null;
    }
    /**
     * If we have not cached the method then we need to go ahead and try to resolve it.
     */
    if (m == null) {
        /**
         * Try to find an instance method from the class target.
         */
        if ((m = getBestCandidate(args, name, cls, cls.getMethods(), false)) != null) {
            addMethodCache(cls, createSignature(name, tk), m);
            parameterTypes = m.getParameterTypes();
        }
        if (m == null) {
            /**
             * If we didn't find anything, maybe we're looking for the actual java.lang.Class methods.
             */
            if ((m = getBestCandidate(args, name, cls, cls.getClass().getDeclaredMethods(), false)) != null) {
                addMethodCache(cls, createSignature(name, tk), m);
                parameterTypes = m.getParameterTypes();
            }
        }
    }
    if (m == null) {
        StringAppender errorBuild = new StringAppender();
        for (int i = 0; i < args.length; i++) {
            errorBuild.append(args[i] != null ? args[i].getClass().getName() : null);
            if (i < args.length - 1)
                errorBuild.append(", ");
        }
        if ("size".equals(name) && args.length == 0 && cls.isArray()) {
            return getLength(ctx);
        }
        System.out.println("{ " + new String(property) + " }");
        throw new PropertyAccessException("unable to resolve method: " + cls.getName() + "." + name + "(" + errorBuild.toString() + ") [arglength=" + args.length + "]", property, st);
    } else {
        for (int i = 0; i < args.length; i++) {
            args[i] = convert(args[i], parameterTypes[i]);
        }
        /**
         * Invoke the target method and return the response.
         */
        try {
            return m.invoke(ctx, args);
        } catch (IllegalAccessException e) {
            try {
                addMethodCache(cls, createSignature(name, tk), (m = getWidenedTarget(m)));
                return m.invoke(ctx, args);
            } catch (Exception e2) {
                throw new PropertyAccessException("unable to invoke method: " + name, property, cursor, e2);
            }
        } catch (RuntimeException e) {
            throw e;
        } catch (Exception e) {
            throw new PropertyAccessException("unable to invoke method: " + name, property, cursor, e);
        }
    }
}