@Override public Map<String, Schema> getSchemas() { doLookup(); Map<String, Schema> schemas = schemaManager.getSchemas(); return schemas; }
@Override public Map<String, Schema> getSchemas() { doLookup(); return schemaManager.getSchemas(); }
@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 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 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; }
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 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 <T> List<T> all(Class<T> clazz) { doLookup(); Schema s = getSchema(clazz); Map<String, Schema> schemas = schemaManager.getSchemas(); Map<BeanId, Bean> beans = beanManager.list(s.getName()); setSchema(schemas, beans); for (Bean bean : beans.values()) { setSingletonReferences(bean, schemas); } return Lists.newArrayList(conversion.convert(beans.values(), clazz)); }
@Override public void merge(Collection<Bean> beans) { if (beans == null || beans.isEmpty()) { return; } doLookup(); setSchema(schemaManager.getSchemas(), beans); validateSchema(beans); // ok to not have validation manager available if (validationManager != null) { validateMerge(beans); } beanManager.merge(beans); }
@Override public void create(Collection<Bean> beans) { if (beans == null || beans.isEmpty()) { return; } doLookup(); core.setSchema(schemaManager.getSchemas(), beans); validateSchema(beans); if (validator.isPresent()) { initReferences(beans); validator.get().validate(beans); } beanManager.create(beans); notificationManager.fireCreate(beans); core.cache(beans); }
@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())); } }
@Override public void set(Collection<Bean> beans) { if (beans == null || beans.isEmpty()) { return; } doLookup(); setSchema(schemaManager.getSchemas(), beans); validateSchema(beans); if (validationManager != null) { initReferences(beans); validateSet(beans); } beanManager.set(beans); }
@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 set(Collection<Bean> beans) { if (beans == null || beans.isEmpty()) { return; } doLookup(); core.setSchema(schemaManager.getSchemas(), beans); validateSchema(beans); if (validator.isPresent()) { initReferences(beans); validateSet(beans); } beanManager.set(beans); notificationManager.fireUpdated(beans); core.cache(beans); }
@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()); } } }
@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); }