/** * Returns {@code true} if given parameter references is not set. */ private boolean parameterReferenceIsNotSet(final BeanReferences parameterReferences) { if (parameterReferences == null) { return true; } return parameterReferences.isEmpty(); }
/** * Removes duplicate names from bean references. */ private void removeAllDuplicateNames(final BeanReferences[] allBeanReferences) { for (int i = 0; i < allBeanReferences.length; i++) { BeanReferences references = allBeanReferences[i]; allBeanReferences[i] = references.removeDuplicateNames(); } }
/** * Converts single string array to an array of bean references. */ private BeanReferences[] convertRefToReferences(final String[] references) { if (references == null) { return null; } BeanReferences[] ref = new BeanReferences[references.length]; for (int i = 0; i < references.length; i++) { ref[i] = BeanReferences.of(references[i]); } return ref; }
/** * Lookups for first founded {@link BeanDefinition bean definition}. * Returns <code>null</code> if none of the beans is found. */ protected BeanDefinition lookupBeanDefinitions(final BeanReferences beanReferences) { final int total = beanReferences.size(); for (int i = 0; i < total; i++) { final String name = beanReferences.name(i); BeanDefinition beanDefinition = lookupBeanDefinition(name); if (beanDefinition != null) { return beanDefinition; } } return null; }
/** * Resolves reference from given values. Returns bean reference of given value or defaults * if given name is blank. */ public BeanReferences resolveReferenceFromValue(final PropertyDescriptor propertyDescriptor, final String refName) { BeanReferences references; if (refName == null || refName.isEmpty()) { references = buildDefaultReference(propertyDescriptor); } else { references = BeanReferences.of(refName); } references = references.removeDuplicateNames(); return references; }
/** * Creates new bean reference. */ public static BeanReferences of(final String... names) { Objects.requireNonNull(names); return new BeanReferences(names); }
/** * Registers static method provider. * * @param providerName provider name * @param type class type * @param staticMethodName static method name * @param arguments method argument types */ public void registerPetiteProvider(final String providerName, final Class type, final String staticMethodName, final Class[] arguments) { ClassDescriptor cd = ClassIntrospector.get().lookup(type); MethodDescriptor md = cd.getMethodDescriptor(staticMethodName, arguments, true); if (md == null) { throw new PetiteException("Provider method not found: " + staticMethodName); } ProviderDefinition providerDefinition = new ProviderDefinition(providerName, md.getMethod()); providers.put(providerName, providerDefinition); }
/** * Registers set injection point. * * @param beanName bean name * @param property set property name */ public void registerPetiteSetInjectionPoint(final String beanName, final String property) { BeanDefinition beanDefinition = lookupExistingBeanDefinition(beanName); ClassDescriptor cd = ClassIntrospector.get().lookup(beanDefinition.type); PropertyDescriptor propertyDescriptor = cd.getPropertyDescriptor(property, true); if (propertyDescriptor == null) { throw new PetiteException("Property not found: " + beanDefinition.type.getName() + '#' + property); } SetInjectionPoint sip = new SetInjectionPoint(propertyDescriptor); beanDefinition.addSetInjectionPoint(sip); }
/** * Returns Petite bean instance named as one of the provided names. * Returns {@code null} if bean is not found. */ protected Object getBean(final BeanReferences beanReferences) { final int total = beanReferences.size(); for (int i = 0; i < total; i++) { String name = beanReferences.name(i); if (name != null) { Object bean = getBean(name); if (bean != null) { return bean; } } } return null; }
public BeanReferences readReferenceFromAnnotation(final FieldDescriptor fieldDescriptor) { final PetiteInject ref = fieldDescriptor.getField().getAnnotation(PetiteInject.class); if (ref == null) { return null; } BeanReferences reference = null; String name = ref.value().trim(); if (name.length() != 0) { reference = BeanReferences.of(name); } //reference = updateReferencesWithDefaultsIfNeeded(propertyDescriptor, reference); reference = reference.removeDuplicateNames(); return reference; }
/** * Converts comma-separated string into array of Bean references. */ private BeanReferences[] convertAnnValueToReferences(String value) { if (value == null) { return null; } value = value.trim(); if (value.length() == 0) { return null; } String[] refNames = Converter.get().toStringArray(value); BeanReferences[] references = new BeanReferences[refNames.length]; for (int i = 0; i < refNames.length; i++) { references[i] = BeanReferences.of(refNames[i].trim()); } return references; }
private BeanReferences updateReferencesWithDefaultsIfNeeded(final PropertyDescriptor propertyDescriptor, BeanReferences references) { if (references == null || references.isEmpty()) { references = buildDefaultReference(propertyDescriptor); } return references; }
return new BeanReferences(newRefs);
@Test void testFieldAnnotation_annotation() { BeanReferences refs = referencesResolver.readReferenceFromAnnotation(field(Revolver.class, "onlyAnnotation")); assertEquals(3, refs.size()); assertEquals("onlyAnnotation", refs.name(0)); assertEquals("string", refs.name(1)); assertEquals("java.lang.String", refs.name(2)); } @Test
/** * Builds default field references. */ public BeanReferences buildDefaultReference(final PropertyDescriptor propertyDescriptor) { final PetiteReferenceType[] lookupReferences = petiteConfig.getLookupReferences(); final String[] references = new String[lookupReferences.length]; for (int i = 0; i < references.length; i++) { switch (lookupReferences[i]) { case NAME: references[i] = propertyDescriptor.getName(); break; case TYPE_SHORT_NAME: references[i] = StringUtil.uncapitalize(propertyDescriptor.getType().getSimpleName()); break; case TYPE_FULL_NAME: references[i] = propertyDescriptor.getType().getName(); break; } } return BeanReferences.of(references); }
@Test void testAnnotation_noMethodArguments_partial() { Arrays.asList( method(Revolver.class, "noMethodArgument_partial"), ctor(Revolver.NoMethodArgument_partial.class) ).forEach(methodOrCtor -> { BeanReferences[] refs = referencesResolver.readAllReferencesFromAnnotation(methodOrCtor); assertEquals(2, refs.length); assertEquals(1, refs[0].size()); assertEquals("innn1", refs[0].name(0)); assertEquals(3, refs[1].size()); assertEquals("in2", refs[1].name(0)); assertEquals("integer", refs[1].name(1)); assertEquals("java.lang.Integer", refs[1].name(2)); }); }
@Test void testResolveReferenceFromValues_explicit() { Arrays.asList( method(Revolver.class, "someArguments"), ctor(Revolver.SomeArguments.class) ).forEach(methodOrCtor -> { BeanReferences[] refs = referencesResolver.resolveReferenceFromValues(methodOrCtor, "i1", "i2"); assertEquals(2, refs.length); assertEquals(1, refs[0].size()); assertEquals("i1", refs[0].name(0)); assertEquals(1, refs[1].size()); assertEquals("i2", refs[1].name(0)); }); }
@Test void testAnnotation_withCsvValue() { Arrays.asList( method(Revolver.class, "someArguments_csv"), ctor(Revolver.SomeArguments_csv.class) ).forEach(methodOrCtor -> { BeanReferences[] refs = referencesResolver.readAllReferencesFromAnnotation(methodOrCtor); assertEquals(2, refs.length); assertEquals(1, refs[0].size()); assertEquals("innn1", refs[0].name(0)); assertEquals(1, refs[1].size()); assertEquals("innn2", refs[1].name(0)); }); }
@Test void testAnnotation_mix() { Arrays.asList( method(Revolver.class, "mix"), ctor(Revolver.Mix.class) ).forEach(methodOrCtor -> { BeanReferences[] refs = referencesResolver.readAllReferencesFromAnnotation(methodOrCtor); assertEquals(2, refs.length); assertEquals(1, refs[0].size()); assertEquals("innn1", refs[0].name(0)); assertEquals(1, refs[1].size()); assertEquals("bbbb", refs[1].name(0)); }); }