/** * Add a empty bean based on id if it does not already exist. */ private Bean putIfAbsent(BeanId id) { Bean bean = beans.get(id); if (bean == null) { bean = Bean.create(id); beans.put(id, bean); } return bean; }
public void addBeans(int num) { for (int i = 0; i < num; i++) { Bean b = Bean.create(BeanId.create(randomAlphanumeric(20), classname)); beans.add(b); } }
@Override public void createSingleton(BeanId singleton) { Bean bean = Bean.create(singleton); try { checkUniquness(bean); } catch (AbortRuntimeException e) { // ignore and return silently. return; } storage.put(bean); }
public static List<Bean> generateBeans(int numBeans, int numProps) { ArrayList<Bean> beans = new ArrayList<>(); for (int i = 0; i < numBeans; i++) { String id = "beanId" + i; String type = "beanType" + i; Bean bean = Bean.create(BeanId.create(id, type)); for (int j = 0; j < numProps; j++) { String _name = "propName" + j; String _value = "propFieldName" + j; bean.addProperty(_name, _value); List<String> d = Arrays.asList("1", "2", "3"); bean.addProperty(_name, d); } beans.add(bean); } return beans; }
@Override public void createSingleton(BeanId singleton) { Map<BeanId, Bean> values = readValuesAsMap(); Bean bean = Bean.create(singleton); try { checkUniquness(bean, values); } catch (AbortRuntimeException e) { // ignore and return silently. return; } values.put(singleton, bean); writeValues(values); }
@Override public Optional<Bean> getEager(BeanId id) { try { if (!begin()) { return Optional.absent(); } List<Bean> beans = findEager(Sets.newHashSet(id)); if (beans.size() == 0) { if (id.isSingleton()) { return Optional.of(Bean.create(id)); } return Optional.absent(); } commit(); return Optional.of(beans.get(0)); } catch (AbortRuntimeException e) { rollback(); if (id.isSingleton()) { return Optional.of(Bean.create(id)); } else { throw e; } } catch (Throwable e) { rollback(); throw new RuntimeException(e); } }
public List<Bean> getBeans() { ArrayList<Bean> result = new ArrayList<Bean>(); for (XmlBean b : beans) { Bean bean = null; if (b.singleton) { bean = Bean.create(BeanId.createSingleton(b.id, b.name)); } else { bean = Bean.create(BeanId.create(b.id, b.name)); } for (XmlBeanPropertyList p : b.properties) { if (p.values != null) bean.addProperty(p.name, p.values); } for (XmlBeanPropertyRefList p : b.references) { if (p.refs != null) bean.addReference(p.name, p.getReferences()); } result.add(bean); } return result; }
@Override public Optional<Bean> getLazy(BeanId id) throws AbortRuntimeException { try { if (!begin()) { return Optional.absent(); } List<Bean> bean = findLazy(Sets.newHashSet(id)); if (bean.size() == 0) { if (id.isSingleton()) { return Optional.of(Bean.create(id)); } return Optional.absent(); } commit(); return Optional.of(bean.get(0)); } catch (AbortRuntimeException e) { rollback(); throw e; } catch (Throwable e) { rollback(); throw new RuntimeException(e); } }
@Test public void test_set_empty_properties() { createThenGet(c1); Bean b = Bean.create(BeanId.create("c1", CHILD_SCHEMA_NAME)); admin.set(b); Bean result = admin.get(b.getId()).get(); assertThat(result.getPropertyNames().size(), is(0)); }
@Override public Optional<Bean> getSingleton(String schemaName) throws IllegalArgumentException { for (Bean bean : storage.all()) { if (bean.getId().getSchemaName().equals(schemaName)) { if (!bean.getId().isSingleton()) { throw new IllegalArgumentException("Schema [" + schemaName + "] is not a get."); } BeanId singletonId = bean.getId(); return getEagerly(singletonId); } } return Optional.of(Bean.create(BeanId.createSingleton(schemaName))); }
public List<Bean> list(Schema schema) { List<Bean> beans = new ArrayList<>(); Map<String, Map<String, Object>> instances; try { instances = (Map) config.getAnyRef(schema.getName()); if (instances == null) { return beans; } } catch (ConfigException e) { return beans; } if (schema.getId().isSingleton()) { final Bean bean = Bean.create(BeanId.createSingleton(schema.getName())); Map<String, Object> properties = (Map) instances; beans.add(bean); constructBean(properties, schema, bean); } else { for (String instanceId : instances.keySet()) { final Map<String, Object> properties = instances.get(instanceId); final Bean bean = Bean.create(BeanId.create(instanceId, schema.getName())); bean.set(schema); beans.add(bean); constructBean(properties, schema, bean); } } return beans; }
@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; }
private Optional<Bean> get(BeanId beanId) { Schema schema = schemas.get(beanId.getSchemaName()); if (schema == null) { throw Events.CFG101_SCHEMA_NOT_EXIST(beanId.getSchemaName()); } Map<String, Map<String, Object>> instances = (Map) config.getAnyRef(schema.getName()); try { final Bean bean; if (schema.getId().isSingleton()) { bean = Bean.create(BeanId.createSingleton(schema.getName())); constructBean((Map) instances, schema, bean); } else { if (instances == null) { return Optional.absent(); } bean = Bean.create(beanId); Map<String, Object> properties = instances.get(beanId.getInstanceId()); constructBean(properties, schema, bean); } return Optional.of(bean); } catch (ConfigException e) { return Optional.absent(); } }
@Override public Bean convert(Object source, Class<? extends Bean> specificType) { ClassIntrospector i = new ClassIntrospector(source.getClass()); Bean bean = Bean.create(getBeanId(source)); for (FieldWrap field : i.getNonStaticFieldList()) { field.checkNotPublic(); Object value = field.getValue(source); if (value == null) { continue; } addProperty(value, bean, field); } Schema schema = conversion.convert(source.getClass(), Schema.class); bean.set(schema); return bean; }
private void setSingletonReferences(Bean bean, Map<String, Schema> schemas) { Schema s = bean.getSchema(); for (SchemaPropertyRef ref : s.get(SchemaPropertyRef.class)) { if (ref.isSingleton()) { Schema singletonSchema = schemas.get(ref.getSchemaName()); Optional<Bean> singleton = beanManager.getSingleton(ref.getSchemaName()); if (!singleton.isPresent()) { initFile(null); Bean fileBean = FILE_CONFIG.get(BeanId.createSingleton(ref.getSchemaName())); if (fileBean != null) { singleton = Optional.of(fileBean); } } if (!singleton.isPresent()) { singleton = Optional.of(Bean.create(BeanId.createSingleton(ref.getSchemaName()))); } singleton.get().set(singletonSchema); BeanId singletonId = singleton.get().getId(); singletonId.setBean(singleton.get()); // recursive call. setSingletonReferences(singleton.get(), schemas); bean.setReference(ref.getName(), singletonId); } } }
@Test public void test_set_merge_without_schema() { Bean b = Bean.create(BeanId.create("1", "missing_schema_name")); try { admin.create(b); fail("Cant add beans without a schema."); } catch (AbortRuntimeException e) { assertThat(e.getEvent().getCode(), is(CFG101)); assertThat(observer.getChanges().size(), is(0)); } try { admin.merge(b); fail("Cant add beans without a schema."); } catch (AbortRuntimeException e) { assertThat(e.getEvent().getCode(), is(CFG101)); assertThat(observer.getChanges().size(), is(0)); } }
@Override public void createSingleton(BeanId singleton) { try { if(!begin()) { throw JPA202_MISSING_THREAD_EM(); } if (isJpaBeanSingleton(singleton.getSchemaName())) { // return silently. return; } JpaBeanSingleton jpaBeanSingleton = new JpaBeanSingleton(singleton.getSchemaName()); getEmOrFail().persist(jpaBeanSingleton); createJpaBean(Bean.create(singleton)); commit(); } catch (AbortRuntimeException e) { rollback(); throw e; } catch (Throwable e) { rollback(); throw new RuntimeException(e); } }
@Test public void test_set_merge_without_schema() { Bean b = Bean.create(BeanId.create("1", "missing_schema_name")); try { admin.create(b); fail("Cant add beans without a schema."); } catch (AbortRuntimeException e) { assertThat(e.getEvent().getCode(), is(CFG101)); } try { admin.merge(b); fail("Cant add beans without a schema."); } catch (AbortRuntimeException e) { assertThat(e.getEvent().getCode(), is(CFG101)); } }
public Bean traverse(Set<Bean> beans, Bean parent) { Bean current = Bean.create(BeanId.create(value + "", "binarytree")); current.setProperty("value", value + ""); if (parent != null) { current.setReference("parent", parent.getId()); } if (left != null) { Bean leftBean = left.traverse(beans, current); current.setReference("left", leftBean.getId()); } if (right != null) { Bean rightBean = right.traverse(beans, current); current.setReference("right", rightBean.getId()); } beans.add(current); return current; }
private Bean copy(Bean bean) { if (bean == null) { return null; } Bean copy = Bean.create(bean.getId()); for (String property : bean.getPropertyNames()) { copy.setProperty(property, bean.getValues(property)); } for (String property : bean.getReferenceNames()) { List<BeanId> ids = bean.getReference(property); for (BeanId id : ids) { copy.addReference(property, BeanId.create(id.getInstanceId(), id.getSchemaName())); } } return copy; } }