How to use

getEager

method

in

org.deephacks.tools4j.config.spi.BeanManager

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

@Test
public void test_create_single() {
  List<Bean> beans = generateBeans(2, 2);
  for (Bean b : beans) {
    manager.create(b);
  }
  for (Bean b : beans) {
    Optional<Bean> r = manager.getEager(b.getId());
    assertThat(r.get(), is(b));
  }
}

@Test
public void test_create_all() {
  List<Bean> beans = generateBeans(2, 2);
  manager.create(beans);
  for (Bean b : beans) {
    Optional<Bean> r = manager.getEager(b.getId());
    assertThat(r.get(), is(b));
  }
}

@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 <T> Optional<T> get(String id, Class<T> configurable) {
  doLookup();
  Schema s = getSchema(configurable);
  Map<String, Schema> schemas = schemaManager.getSchemas();
  BeanId beanId = BeanId.create(id, s.getName());
  Optional<Bean> bean = beanManager.getEager(beanId);
  if (!bean.isPresent()) {
    initFile(configurable);
    Bean fileBean = FILE_CONFIG.get(beanId);
    if (fileBean != null) {
      bean = Optional.of(fileBean);
    } else {
      return Optional.absent();
    }
  }
  core.setSchema(bean.get(), schemas);
  setSingletonReferences(bean.get(), schemas);
  T object = conversion.convert(bean.get(), configurable);
  core.cache(bean.get());
  return Optional.of(object);
}

private void initReferences(Collection<Bean> beans) {
  Map<BeanId, Bean> indexed = BeanUtils.uniqueIndex(beans);
  for (Bean bean : beans) {
    for (String name : bean.getReferenceNames()) {
      List<BeanId> ids = bean.getReference(name);
      if (ids == null) {
        continue;
      }
      for (BeanId id : ids) {
        Bean ref = indexed.get(id);
        if (ref == null) {
          // TODO: investigate if eager is really needed
          Optional<Bean> optionalRef = beanManager.getEager(id);
          if (optionalRef.isPresent()) {
            core.setSchema(optionalRef.get(), schemaManager.getSchemas());
            ref = optionalRef.get();
          }
        }
        id.setBean(ref);
      }
    }
  }
}

@Test
public void test_create_default() {
  List<Bean> beans = generateBeans(2, 2);
  for (Bean bean : beans) {
    bean.setDefault();
  }
  manager.create(beans);
  for (Bean b : beans) {
    Optional<Bean> r = manager.getEager(b.getId());
    assertThat(r.get(), is(b));
    assertThat(r.get().isDefault(), is(b.isDefault()));
  }
}

@Override
public <T> T get(Class<T> configurable) {
  doLookup();
  Schema schema = getSchema(configurable);
  BeanId singleton = getSingletonId(schema, configurable);
  Optional<Bean> bean = beanManager.getEager(singleton);
  if (!bean.isPresent()) {
    initFile(configurable);
    Bean fileBean = FILE_CONFIG.get(singleton);
    if (fileBean != null) {
      fileBean.set(schema);
      bean = Optional.of(fileBean);
    }
    if (bean.isPresent()) {
      T object = conversion.convert(bean.get(), configurable);
      core.cache(bean.get());
      return object;
    }
  }
  if (!bean.isPresent()) {
    bean = Optional.of(Bean.create(BeanId.createSingleton(schema.getName())));
  }
  core.setSchema(bean.get(), schemas);
  setSingletonReferences(bean.get(), schemas);
  T object = conversion.convert(bean.get(), configurable);
  core.cache(bean.get());
  return object;
}

/**
 * Used for setting or creating a single bean.
 */
@SuppressWarnings("unused")
private void initalizeReferences(Bean bean) {
  for (String name : bean.getReferenceNames()) {
    List<BeanId> values = bean.getReference(name);
    if (values == null) {
      continue;
    }
    for (BeanId beanId : values) {
      Optional<Bean> ref = beanManager.getEager(beanId);
      if (ref.isPresent()) {
        beanId.setBean(ref.get());
      }
      core.setSchema(beanId.getBean(), schemaManager.getSchemas());
    }
  }
}

@Override
public void merge(Collection<Bean> beans) {
  if (beans == null || beans.isEmpty()) {
    return;
  }
  doLookup();
  core.setSchema(schemaManager.getSchemas(), beans);
  validateSchema(beans);
  // ok to not have validation manager available
  if (validator.isPresent()) {
    validateMerge(beans);
  }
  beanManager.merge(beans);
  notificationManager.fireUpdated(beans);
  for (Bean bean : beans) {
    // must refresh the bean from storage since it is merged.
    Optional<Bean> refreshed = beanManager.getEager(bean.getId());
    if (refreshed.isPresent()) {
      core.cache(refreshed.get());
    }
  }
}

private void initReferences(Collection<Bean> beans) {
  Map<BeanId, Bean> indexed = BeanUtils.uniqueIndex(beans);
  for (Bean bean : beans) {
    for (String name : bean.getReferenceNames()) {
      List<BeanId> ids = bean.getReference(name);
      for (BeanId id : ids) {
        Bean ref = indexed.get(id);
        if (ref == null) {
          // TODO: investigate if eager is really needed 
          ref = beanManager.getEager(id);
          setSchema(ref, schemaManager.getSchemas());
        }
        id.setBean(ref);
      }
    }
  }
}

Optional<Bean> optional = beanManager.getEager(beanId);
if (optional.isPresent()) {
  ref = optional.get();

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

/**
 * Used for setting or creating a single bean.
 */
private void initalizeReferences(Bean bean) {
  for (String name : bean.getReferenceNames()) {
    List<BeanId> values = bean.getReference(name);
    if (values == null) {
      continue;
    }
    for (BeanId beanId : values) {
      Bean ref = beanManager.getEager(beanId);
      beanId.setBean(ref);
      setSchema(beanId.getBean(), schemaManager.getSchemas());
    }
  }
}

/**
 * Used for setting or creating a multiple beans. 
 * 
 * We must consider that the operation may include beans that have 
 * references betewen eachother. User provided beans are 
 * prioritized and the storage is secondary for looking up references.  
 */
private void initalizeReferences(Collection<Bean> beans) {
  Map<BeanId, Bean> userProvided = BeanUtils.uniqueIndex(beans);
  for (Bean bean : beans) {
    for (String name : bean.getReferenceNames()) {
      List<BeanId> values = bean.getReference(name);
      if (values == null) {
        continue;
      }
      for (BeanId beanId : values) {
        // the does not exist in storage, but may exist in the
        // set of beans provided by the user.
        Bean ref = userProvided.get(beanId);
        if (ref == null) {
          ref = beanManager.getEager(beanId);
        }
        beanId.setBean(ref);
        setSchema(beanId.getBean(), schemaManager.getSchemas());
      }
    }
  }
}

@Override
public <T> T get(String id, Class<T> clazz) {
  doLookup();
  Schema s = getSchema(clazz);
  Map<String, Schema> schemas = schemaManager.getSchemas();
  BeanId beanId = BeanId.create(id, s.getName());
  Bean bean = beanManager.getEager(beanId);
  if (bean == null) {
    throw Events.CFG304_BEAN_DOESNT_EXIST(beanId);
  }
  setSchema(bean, schemas);
  setSingletonReferences(bean, schemas);
  return conversion.convert(bean, clazz);
}

Optional<Bean> grandpa = manager.getEager(grandParentId);