public void add(Collection<Class<?>> clazzes) { for (Class<?> clazz : clazzes) { add(clazz); } }
public ClassLoader getClassLoader() { return loadJars(jar); }
public static Bean toBean(Object object) { return CONVERSION.convert(object, Bean.class); }
@Override public void delete(String name, Collection<String> instances) { Preconditions.checkNotNull(name); if (instances == null || instances.isEmpty()) { return; } doLookup(); Collection<Bean> beans = beanManager.delete(name, instances); core.setSchema(schemaManager.getSchemas(), beans); notificationManager.fireDelete(beans); core.cacheRemove(name, instances); }
@Override public Bean get(BeanId beanId) { Preconditions.checkNotNull(beanId); doLookup(); Bean bean = beanManager.getEager(beanId); Map<String, Schema> schemas = schemaManager.getSchemas(); setSchema(bean, schemas); setSingletonReferences(bean, schemas); return bean; }
@Override public void create(Collection<Bean> beans) { if (beans == null || beans.isEmpty()) { return; } doLookup(); setSchema(schemaManager.getSchemas(), beans); validateSchema(beans); if (validationManager != null) { initReferences(beans); validationManager.validate(beans); } beanManager.create(beans); }
@Override public void register(String schemaName, Class<?> clazz) throws AbortRuntimeException { ClassRepository repos = new ClassRepository(); repos.add(clazz); repos.add(getTransitiveDependencies(clazz)); repos.write(); }
@Override public void unregister(Class<?>... configurable) { doLookup(); for (Class<?> clazz : configurable) { Schema schema = conversion.convert(clazz, Schema.class); schemaManager.removeSchema(schema.getName()); core.removeIndex(schema); } }
@Override public void unregister(Class<?>... configurable) { doLookup(); for (Class<?> clazz : configurable) { Schema schema = conversion.convert(clazz, Schema.class); schemaManager.removeSchema(schema.getName()); // ok to not have validation manager available if (validationManager != null) { validationManager.unregister(schema.getName()); } } }
@Override public Map<String, Schema> getSchemas() { doLookup(); return schemaManager.getSchemas(); }
private URLClassLoader createClassLoaderFrom(File[] jars, ClassLoader parent) { URL[] urls = toURLs(jars); URLClassLoader classLoader = new URLClassLoader(urls, parent); return classLoader; }
public void register(Observer observer) { for (Class<?> observedClass : observer.getObservedClasses()) { observers.put(observedClass, observer); } }
private ClassLoader loadJars(File... jars) { ClassLoader cl = Thread.currentThread().getContextClassLoader(); URLClassLoader jarExtensions = createClassLoaderFrom(jars, cl); return jarExtensions; }
public void write() { Archiver.write(generatedDir, jar, dependencies.toArray(new Class[0])); dependencies.clear(); }
@Override public void delete(BeanId beanId) { Preconditions.checkNotNull(beanId); doLookup(); Bean bean = beanManager.delete(beanId); core.setSchema(schemaManager.getSchemas(), Arrays.asList(bean)); notificationManager.fireDelete(Lists.newArrayList(bean)); core.cacheRemove(beanId); }
@Override public <T> T singleton(Class<T> configurable) { doLookup(); Schema schema = conversion.convert(configurable, Schema.class); BeanId singleton = getSingletonId(schema, configurable); Map<String, Schema> schemas = schemaManager.getSchemas(); Bean bean = beanManager.getEager(singleton); bean.set(schema); setSingletonReferences(bean, schemas); return conversion.convert(bean, configurable); }
@Override public Map<String, Schema> getSchemas() { doLookup(); Map<String, Schema> schemas = schemaManager.getSchemas(); return schemas; }
private Collection<Bean> convertToBeans(Collection<?> objects) { ArrayList<Bean> beans = new ArrayList<>(); for (Object object : objects) { if(object instanceof Bean) { beans.add((Bean) object); } else { Bean bean = conversion.convert(object, Bean.class); beans.add(bean); } } return beans; } }