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