How to use

SchemaManager

in

org.deephacks.tools4j.config.spi

@Test
public void test_get_schemas() {
  Set<Schema> schemas = generateSchemas(10, 10);
  for (Schema schema : schemas) {
    manager.registerSchema(schema);
    Schema response = manager.getSchema(schema.getName());
    assertThat(schema, equalTo(response));
  }
  Map<String, Schema> schemaNames = manager.getSchemas();
  for (Schema s : schemas) {
    assertTrue(schemaNames.containsKey(s.getName()));
  }
}

@Test
public void test_remove_schema() {
  Set<Schema> schemas = generateSchemas(2, 2);
  for (Schema schema : schemas) {
    manager.registerSchema(schema);
    Schema response = manager.getSchema(schema.getName());
    assertThat(schema, equalTo(response));
  }
  Schema s = schemas.iterator().next();
  assertThat(manager.getSchema(s.getName()), is(s));
  manager.removeSchema(s.getName());
  try {
    s = manager.getSchema(s.getName());
  } catch (AbortRuntimeException e) {
    assertThat(e.getEvent().getCode(), is(Events.CFG101));
  }
}

@Test
public void test_add_get_schema() {
  Set<Schema> schemas = generateSchemas(10, 10);
  for (Schema schema : schemas) {
    manager.registerSchema(schema);
    Schema response = manager.getSchema(schema.getName());
    assertThat(schema, equalTo(response));
  }
}

@Override
public Map<String, Schema> getSchemas() {
  doLookup();
  Map<String, Schema> schemas = schemaManager.getSchemas();
  return schemas;
}

@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());
    core.removeIndex(schema);
  }
}

  private Schema getSchema(Class<?> clazz) {
    Schema schema = schemas.get(clazz);
    if(schema != null) {
      return schema;
    }
    ClassIntrospector introspector = new ClassIntrospector(clazz);
    Config config = introspector.getAnnotation(Config.class);
    if (config == null) {
      throw CFG102_NOT_CONFIGURABLE(clazz);
    }
    String schemaName = config.name();
    if (schemaName == null || "".equals(schemaName)) {
      schemaName = clazz.getName();
    }
    schema = conversion.convert(clazz, Schema.class);
    for (Class<?> cls : schema.getReferenceSchemaTypes()) {
      if (schemas.get(clazz) != null) {
        getSchema(cls);
      }
    }
    properties.registerSchema(schema);
    schemas.put(schema.getName(), schema);
    schemaManager.registerSchema(schema);
    core.putIndex(schema);
    return schema;
  }
}

@Override
public void register(Class<?>... configurable) {
  doLookup();
  for (Class<?> clazz : configurable) {
    Schema schema = conversion.convert(clazz, Schema.class);
    schemaManager.regsiterSchema(schema);
    if (schema.getId().isSingleton()) {
      beanManager.createSingleton(getSingletonId(schema, clazz));
    }
    // ok to not have validation manager available
    if (validationManager != null) {
      validationManager.register(schema.getName(), clazz);
    }
  }
}

@Override
public Map<String, Schema> getSchemas() {
  doLookup();
  return schemaManager.getSchemas();
}

  private Schema getSchema(Class<?> clazz) {
    ClassIntrospector introspector = new ClassIntrospector(clazz);
    Config config = introspector.getAnnotation(Config.class);
    if (config == null) {
      throw CFG102_NOT_CONFIGURABLE(clazz);
    }
    String schemaName = config.name();
    if (schemaName == null || "".equals(schemaName)) {
      schemaName = clazz.getName();
    }
    return schemaManager.getSchema(schemaName);
  }
}

@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 List<Bean> list(String schemaName) {
  Preconditions.checkNotNull(schemaName);
  doLookup();
  Map<BeanId, Bean> beans = beanManager.list(schemaName);
  core.setSchema(schemaManager.getSchemas(), beans);
  return new ArrayList<>(beans.values());
}

@Override
public List<Bean> list(String schemaName) {
  Preconditions.checkNotNull(schemaName);
  doLookup();
  Map<BeanId, Bean> beans = beanManager.list(schemaName);
  setSchema(schemaManager.getSchemas(), beans);
  return new ArrayList<Bean>(beans.values());
}

@Override
public Optional<Bean> get(BeanId beanId) {
  Preconditions.checkNotNull(beanId);
  doLookup();
  Optional<Bean> bean = beanManager.getEager(beanId);
  if (!bean.isPresent()) {
    return bean;
  }
  Map<String, Schema> schemas = schemaManager.getSchemas();
  core.setSchema(bean.get(), schemas);
  setSingletonReferences(bean.get(), schemas);
  return bean;
}

@Override
public List<Bean> list(String schemaName, Collection<String> instanceIds) {
  Preconditions.checkNotNull(schemaName);
  if (instanceIds == null || instanceIds.isEmpty()) {
    return new ArrayList<Bean>();
  }
  doLookup();
  Map<BeanId, Bean> beans = beanManager.list(schemaName);
  Map<BeanId, Bean> result = new HashMap<BeanId, Bean>();
  for (String instanceId : instanceIds) {
    Bean b = beans.get(BeanId.create(instanceId, schemaName));
    result.put(b.getId(), b);
  }
  Map<String, Schema> schemas = schemaManager.getSchemas();
  setSchema(schemas, result);
  return new ArrayList<Bean>(result.values());
}

@Override
public List<Bean> list(String schemaName, Collection<String> instanceIds) {
  Preconditions.checkNotNull(schemaName);
  if (instanceIds == null || instanceIds.isEmpty()) {
    return new ArrayList<>();
  }
  doLookup();
  Map<BeanId, Bean> beans = beanManager.list(schemaName, instanceIds);
  Map<BeanId, Bean> result = new HashMap<>();
  for (String instanceId : instanceIds) {
    Bean b = beans.get(BeanId.create(instanceId, schemaName));
    result.put(b.getId(), b);
  }
  Map<String, Schema> schemas = schemaManager.getSchemas();
  core.setSchema(schemas, result);
  return new ArrayList<>(result.values());
}

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

private void validateMerge(Collection<Bean> mergebeans) {
  Map<BeanId, Bean> beansToValidate = beanManager.getBeanToValidate(mergebeans);
  core.setSchema(schemaManager.getSchemas(), beansToValidate);
  // since we are validating mergebean predecessors, we need to make sure
  // that they see a merged reference (not unmerged reference currently in storage)
  // before validation can proceed.
  for (Bean mergebean : mergebeans) {
    ArrayList<Bean> mergeBeanReferences = new ArrayList<>();
    ArrayList<Bean> checked = new ArrayList<>();
    findReferences(mergebean.getId(), beansToValidate.values(), mergeBeanReferences,
        checked);
    // merge list references
    merge(mergeBeanReferences, mergebean);
  }
  // ready to validate
  validator.get().validate(beansToValidate.values());
}

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