@Override protected final InvocationHandler prepareInvocationHandler(Object openClassInstance, Map<Method, IOpenMember> methodMap, IRuntimeEnv runtimeEnv) { return new OpenLRulesInvocationHandler(openClassInstance, runtimeEnv, methodMap); } }
public Class<?> generateInterface(String className, IOpenClass openClass, ClassLoader classLoader) throws Exception { boolean f1 = (includes == null) || (includes.length == 0); boolean f2 = (excludes == null) || (excludes.length == 0); if (f1 && f2) { return InterfaceGenerator.generateInterface(className, openClass, classLoader); } else { return InterfaceGenerator.generateInterface(className, openClass, classLoader, includes, excludes); } } }
@Override protected Class<?>[] prepareInstanceInterfaces() { return new Class[]{getInterfaceClass(), IEngineWrapper.class, IRulesRuntimeContextProvider.class}; }
private AlgorithmTableParserManager() { URL sourceFile = AlgorithmTableParserManager.class.getResource("AlgorithmTableSpecification.xls"); RulesEngineFactory<IAlgorithmTableParserManager> engineFactory = new RulesEngineFactory<IAlgorithmTableParserManager>( sourceFile, IAlgorithmTableParserManager.class); engineFactory.setExecutionMode(true); rulesWrapperInstance = (IAlgorithmTableParserManager) engineFactory.makeInstance(); }
private TablePropertyDefinition[] loadTablePropertyDefinitions() { RulesEngineFactory<ITablePropertyDefinitionLoader> engineFactory = new RulesEngineFactory<ITablePropertyDefinitionLoader>( CodeGenConstants.DEFINITIONS_XLS, ITablePropertyDefinitionLoader.class); return engineFactory.newEngineInstance().getDefinitions(); }
/** * Creates rule info using rule name, parameters types and return type. * * @param ruleName rule name * @param paramTypes parameters types * @param returnType return type * @return rule info */ public static RuleInfo createRuleInfo(String ruleName, Class<?>[] paramTypes, Class<?> returnType) { RuleInfo ruleInfo = new RuleInfo(); ruleInfo.setName(ruleName); ruleInfo.setParamTypes(paramTypes); ruleInfo.setReturnType(returnType); return ruleInfo; }
@Override public Object instantiate(Class<?> rulesClass) throws RulesInstantiationException { ClassLoader oldClassLoader = Thread.currentThread().getContextClassLoader(); Thread.currentThread().setContextClassLoader(getClassLoader()); try { return getEngineFactory().newEngineInstance(); } finally { Thread.currentThread().setContextClassLoader(oldClassLoader); } }
@Override protected void validateReturnType(IOpenMethod openMethod, Method interfaceMethod) { if (!(interfaceMethod.isAnnotationPresent(ServiceCallAfterInterceptor.class) || interfaceMethod.isAnnotationPresent(ServiceCallAfterInterceptors.class) || interfaceMethod.isAnnotationPresent(ServiceCallAroundInterceptor.class))) { super.validateReturnType(openMethod, interfaceMethod); } } }
@Override public void reset() { super.reset(); if (engineFactory != null) { getEngineFactory().reset(false); } }
private void validateAliasValue(Object value, IOpenClass openClass) { if (openClass.isArray()) { Object[] values = (Object[]) value; for (Object o : values) { testLookupValue(o, openClass); } } else { testLookupValue(value, openClass); } }
private void doValidate(IRuntimeEnv env, Object[] objs, IOpenClass openType) { for (Object obj : objs) { if (obj == null) { continue; } if (openType instanceof ComponentTypeArrayOpenClass) { doValidate(env, (Object[]) obj, openType.getComponentClass()); } else if (openType instanceof DatatypeOpenClass) { doValidate(env, obj, openType); } } }
public void reset(boolean resetInterface) { super.reset(); if (resetInterface) { setInterfaceClass(null); } }
public IRulesRuntimeContext getRuntimeContext() { return (IRulesRuntimeContext) getRuntimeEnv().getContext(); }
private ContextPropertyDefinition[] loadContextPropertyDefinitions() { RulesEngineFactory<IContextPropertyDefinitionLoader> engineFactory = new RulesEngineFactory<IContextPropertyDefinitionLoader>( CodeGenConstants.DEFINITIONS_XLS, IContextPropertyDefinitionLoader.class); return engineFactory.newEngineInstance().getContextDefinitions(); }
/** * Generates interface class using methods and fields of given IOpenClass * instance. * * @param className name of result class * @param openClass IOpenClass instance * @param classLoader class loader what will be used to load generated * interface * @return generated interface * @throws Exception if an error has occurred */ public static Class<?> generateInterface(String className, IOpenClass openClass, ClassLoader classLoader) throws Exception { return generateInterface(className, openClass, classLoader, null, null); }
@Override public Object instantiate(Class<?> rulesClass) throws RulesInstantiationException { ClassLoader oldClassLoader = Thread.currentThread().getContextClassLoader(); Thread.currentThread().setContextClassLoader(getClassLoader()); try { return getEngineFactory().newEngineInstance(); } finally { Thread.currentThread().setContextClassLoader(oldClassLoader); } }
@Override protected InvocationHandler prepareInvocationHandler(Object openClassInstance, Map<Method, IOpenMember> methodMap, IRuntimeEnv runtimeEnv) { return new OpenLRulesInvocationHandler(openClassInstance, runtimeEnv, methodMap); } }
@Override protected void validateReturnType(IOpenMethod openMethod, Method interfaceMethod) { if (!(interfaceMethod.isAnnotationPresent(ServiceCallAfterInterceptor.class) || interfaceMethod.isAnnotationPresent(ServiceCallAfterInterceptors.class) || interfaceMethod.isAnnotationPresent(ServiceCallAroundInterceptor.class))) { super.validateReturnType(openMethod, interfaceMethod); } } }
@Override public void reset() { super.reset(); if (engineFactory != null) { getEngineFactory().reset(false); } }
private String[] loadTablePriorityRules() { RulesEngineFactory<ITablesPriorityLoader> engineFactory = new RulesEngineFactory<ITablesPriorityLoader>( CodeGenConstants.DEFINITIONS_XLS, ITablesPriorityLoader.class); return engineFactory.newEngineInstance().getTablesPriorityRules(); }