How to use org.deephacks.tools4j.config.spi

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 BeanQuery newQuery(String schemaName) {
  doLookup();
  Schema schema = schemaManager.getSchema(schemaName);
  Preconditions.checkNotNull(schema, "Schema " + schemaName + " does not exist.");
  return beanManager.newQuery(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();
}

@Override
public void registerObserver(Object observer) {
  doLookup();
  notificationManager.register(new Observer(observer));
}

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;
  }
}