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(); }
@Override protected Class<?>[] prepareInstanceInterfaces() { return new Class[]{getInterfaceClass(), IEngineWrapper.class, IRulesRuntimeContextProvider.class}; }
private ContextPropertyDefinition[] loadContextPropertyDefinitions() { RulesEngineFactory<IContextPropertyDefinitionLoader> engineFactory = new RulesEngineFactory<IContextPropertyDefinitionLoader>( CodeGenConstants.DEFINITIONS_XLS, IContextPropertyDefinitionLoader.class); return engineFactory.newEngineInstance().getContextDefinitions(); }
serviceClass = null; if (engineFactory == null || (serviceClass != null && !engineFactory.getInterfaceClass().equals(serviceClass))) { engineFactory = new RulesEngineFactory<>(createVirtualSourceCodeModule(), (Class<Object>) serviceClass); engineFactory.setExecutionMode(isExecutionMode()); includes = allIncludes.toArray(includes); excludes = allExcludes.toArray(excludes); engineFactory.setInterfaceClassGenerator(new InterfaceClassGeneratorImpl(includes, excludes)); engineFactory.setDependencyManager(getDependencyManager());
RulesEngineFactory factory = new RulesEngineFactory(source); factory.setExecutionMode(true); Class<?> instanceClass = factory.getInterfaceClass(); Object instance = factory.newInstance(); factory.getCompiledOpenClass().throwErrorExceptionsIfAny(); String name = "org.openl.rules.java::" + factory.getSourceCode().getUri(); IOpenLConfiguration config = OpenLConfiguration.getInstance(name, factory.getUserContext());
private CompiledOpenClass initializeOpenClass() { // put prebinder to openl IPrebindHandler prebindHandler = LazyBinderInvocationHandler.getPrebindHandler(); try { LazyBinderInvocationHandler.setPrebindHandler(new IPrebindHandler() { @Override public IOpenMethod processMethodAdded(IOpenMethod method, XlsLazyModuleOpenClass moduleOpenClass) { return makeLazyMethod(moduleOpenClass, method); } @Override public IOpenField processFieldAdded(IOpenField field, XlsLazyModuleOpenClass moduleOpenClass) { return makeLazyField(moduleOpenClass, field); } }); IOpenSourceCodeModule mainModule = createMainModule(); RulesEngineFactory<?> engineFactory = new RulesEngineFactory<Object>(mainModule, AOpenLEngineFactory.DEFAULT_USER_HOME, getOpenlName());// FIXME engineFactory.setDependencyManager(dependencyManager); engineFactory.setExecutionMode(true); CompiledOpenClass result = engineFactory.getCompiledOpenClass(); return result; } finally { LazyBinderInvocationHandler.setPrebindHandler(prebindHandler); } }
private List<EnumerationDescriptor> loadEnumerations() { List<EnumerationDescriptor> descriptors = new ArrayList<>(); RulesEngineFactory<IEmptyLoader> engineFactory = new RulesEngineFactory<>(CodeGenConstants.DEFINITIONS_XLS, IEmptyLoader.class); IOpenClass openClass = engineFactory.getCompiledOpenClass().getOpenClass(); IRuntimeEnv env = engineFactory.getOpenL().getVm().getRuntimeEnv(); Object openClassInstance = openClass.newInstance(env); for (IOpenField field : openClass.getFields().values()) { IOpenClass type = field.getType(); Class<?> clazz = type.getInstanceClass(); if (clazz.equals(EnumPropertyDefinition[].class)) { String name = field.getName(); String enumName = getEnumName(name); EnumPropertyDefinition[] values = (EnumPropertyDefinition[]) field.get(openClassInstance, env); EnumerationDescriptor descriptor = new EnumerationDescriptor(); descriptor.setEnumName(enumName); descriptor.setValues(values); descriptors.add(descriptor); } } return descriptors; }
public Class<T> getInterfaceClass() { if (super.getInterfaceClass() == null) { IOpenClass openClass = getCompiledOpenClass().getOpenClass(); String className = openClass.getName(); ClassLoader classLoader = getCompiledOpenClass().getClassLoader(); try { try { Class<T> interfaceClass = (Class<T>) classLoader.loadClass(className); log.warn("Previously generated interface '{}' has been used as service class.", className); setInterfaceClass(interfaceClass); return interfaceClass; } catch (ClassNotFoundException e) { Class<T> interfaceClass = (Class<T>) interfaceClassGenerator.generateInterface(className, openClass, classLoader); setInterfaceClass(interfaceClass); return interfaceClass;
@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); } }
serviceClass = null; if (engineFactory == null || (serviceClass != null && !engineFactory.getInterfaceClass().equals(serviceClass))) { engineFactory = new RulesEngineFactory<>(createVirtualSourceCodeModule(), (Class<Object>) serviceClass); engineFactory.setExecutionMode(isExecutionMode()); includes = allIncludes.toArray(includes); excludes = allExcludes.toArray(excludes); engineFactory.setInterfaceClassGenerator(new InterfaceClassGeneratorImpl(includes, excludes)); engineFactory.setDependencyManager(getDependencyManager());
private CompiledOpenClass initializeOpenClass() { // put prebinder to openl IPrebindHandler prebindHandler = LazyBinderInvocationHandler.getPrebindHandler(); try { LazyBinderInvocationHandler.setPrebindHandler(new IPrebindHandler() { @Override public IOpenMethod processMethodAdded(IOpenMethod method, XlsLazyModuleOpenClass moduleOpenClass) { return makeLazyMethod(moduleOpenClass, method); } @Override public IOpenField processFieldAdded(IOpenField field, XlsLazyModuleOpenClass moduleOpenClass) { return makeLazyField(moduleOpenClass, field); } }); IOpenSourceCodeModule mainModule = createMainModule(); RulesEngineFactory<?> engineFactory = new RulesEngineFactory<Object>(mainModule, AOpenLEngineFactory.DEFAULT_USER_HOME, getOpenlName());// FIXME engineFactory.setDependencyManager(dependencyManager); engineFactory.setExecutionMode(true); CompiledOpenClass result = engineFactory.getCompiledOpenClass(); return result; } finally { LazyBinderInvocationHandler.setPrebindHandler(prebindHandler); } }
@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); } }
serviceClass = null; if (engineFactory == null || (serviceClass != null && !engineFactory.getInterfaceClass().equals(serviceClass))) { if (getModule().getExtension() != null) { IExtensionDescriptor extensionDescriptor = ExtensionDescriptorFactory.getExtensionDescriptor(getModule().getExtension(), engineFactory = new RulesEngineFactory<Object>(openlName, source, serviceClass); } else { IOpenSourceCodeModule source = getSourceCode(getModule()); source.setParams(prepareExternalParameters()); engineFactory = new RulesEngineFactory<Object>(source, serviceClass); includes = methodFilter.getIncludes().toArray(includes); excludes = methodFilter.getExcludes().toArray(excludes); engineFactory.setInterfaceClassGenerator(new InterfaceClassGeneratorImpl(includes, excludes)); engineFactory.setExecutionMode(isExecutionMode()); engineFactory.setDependencyManager(getDependencyManager());
private String[] loadTablePriorityRules() { RulesEngineFactory<ITablesPriorityLoader> engineFactory = new RulesEngineFactory<ITablesPriorityLoader>( CodeGenConstants.DEFINITIONS_XLS, ITablesPriorityLoader.class); return engineFactory.newEngineInstance().getTablesPriorityRules(); }
@Override public Class<?> getGeneratedRulesClass() throws RulesInstantiationException { // Using project class loader for interface generation. ClassLoader oldClassLoader = Thread.currentThread().getContextClassLoader(); Thread.currentThread().setContextClassLoader(getClassLoader()); try { return getEngineFactory().getInterfaceClass(); } catch (Exception e) { throw new RulesInstantiationException("Failed to resolve interface!", e); } finally { Thread.currentThread().setContextClassLoader(oldClassLoader); } }
@Override public Object instantiate(Class<?> rulesClass) throws RulesInstantiationException { // Ensure that instantiation will be done in strategy classLoader. // ClassLoader oldClassLoader = Thread.currentThread().getContextClassLoader(); Thread.currentThread().setContextClassLoader(getClassLoader()); try { return getEngineFactory().newEngineInstance(); } catch (Exception e) { throw new RulesInstantiationException(e); } finally { Thread.currentThread().setContextClassLoader(oldClassLoader); } }
serviceClass = null; if (engineFactory == null || (serviceClass != null && !engineFactory.getInterfaceClass().equals(serviceClass))) { if (getModule().getExtension() != null) { IExtensionDescriptor extensionDescriptor = ExtensionDescriptorFactory.getExtensionDescriptor(getModule().getExtension(), engineFactory = new RulesEngineFactory<Object>(openlName, source, serviceClass); } else { IOpenSourceCodeModule source = getSourceCode(getModule()); source.setParams(prepareExternalParameters()); engineFactory = new RulesEngineFactory<Object>(source, serviceClass); includes = methodFilter.getIncludes().toArray(includes); excludes = methodFilter.getExcludes().toArray(excludes); engineFactory.setInterfaceClassGenerator(new InterfaceClassGeneratorImpl(includes, excludes)); engineFactory.setExecutionMode(isExecutionMode()); engineFactory.setDependencyManager(getDependencyManager());
private TablePropertyDefinition[] loadTablePropertyDefinitions() { RulesEngineFactory<ITablePropertyDefinitionLoader> engineFactory = new RulesEngineFactory<ITablePropertyDefinitionLoader>( CodeGenConstants.DEFINITIONS_XLS, ITablePropertyDefinitionLoader.class); return engineFactory.newEngineInstance().getDefinitions(); }
@Override public Class<?> getGeneratedRulesClass() throws RulesInstantiationException { // Using project class loader for interface generation. ClassLoader oldClassLoader = Thread.currentThread().getContextClassLoader(); Thread.currentThread().setContextClassLoader(getClassLoader()); try { return getEngineFactory().getInterfaceClass(); } catch (Exception e) { throw new RulesInstantiationException("Failed to resolve interface!", e); } finally { Thread.currentThread().setContextClassLoader(oldClassLoader); } }
@Override public Object instantiate(Class<?> rulesClass) throws RulesInstantiationException { // Ensure that instantiation will be done in strategy classLoader. // ClassLoader oldClassLoader = Thread.currentThread().getContextClassLoader(); Thread.currentThread().setContextClassLoader(getClassLoader()); try { return getEngineFactory().newEngineInstance(); } catch (Exception e) { throw new RulesInstantiationException(e); } finally { Thread.currentThread().setContextClassLoader(oldClassLoader); } }