/*************************************************************************** * * Creates an enhanced item. * * @param bean the original item * @return the enhanced item * **************************************************************************/ @Nonnull public static <T> T createEnhancedItem (@Nonnull final T bean, @Nonnull final Object ... arguments) { return (T)instance.createEnhancedBean(bean, arguments); }
/*************************************************************************** * * {@inheritDoc} * **************************************************************************/ @Override public boolean isItemAvailable (@Nonnull final Class<?> metadataItemClass, @Nonnull final FindOption ... options) throws NoSuchMetadataTypeException { final StorageType storageType = MetadataSpiUtils.findOption(options, StorageType.DEFAULT, StorageType.class); final ClassMap<List<MetadataItemHolder<?>>> holderMapByClass = findHolderMap(storageType); return holderMapByClass.containsKey(metadataItemClass); }
private int depth (@Nonnull final Class<?> clazz) { final Class<?> superClass = clazz.getSuperclass(); return (superClass == null) ? 0 : depth(superClass) + 1; } });
@Nonnull public <Item> Item createItem (@Nonnull final Class<Item> itemClass) throws Exception { return MetadataItemEnhancer.createEnhancedItem(itemClass.newInstance()); } };
/*************************************************************************** * * {@inheritDoc} * **************************************************************************/ @Nonnull final public List<MetadataItemHolder<Item>> findOrCreateItems (@Nonnull final DataObject dataObject, @Nonnull final FindOption ... options) { logger.fine("findOrCreateItems(%s, %s)", dataObject, Arrays.toString(options)); if (dataObject == null) { throw new IllegalArgumentException("dataObject is mandatory"); } MetadataSpiUtils.validateOptions(options); final List<MetadataItemHolder<Item>> holders = findItems(itemClass, dataObject, options); // The new holder will have isAvailable() == false // FIXME: have a Map and make sure that the same instance for each DataObject is returned if (holders.isEmpty()) { holders.add(createNewItem()); } return holders; }
/*************************************************************************** * * {@inheritDoc} * **************************************************************************/ @Override public <Item> int storeItem (@Nonnull final MetadataItemHolder<Item> holder, @Nonnull final StoreOption ... options) throws NoSuchMetadataTypeException { logger.info("storeItem(%s, %s)", holder, Arrays.toString(options)); if (holder == null) { throw new IllegalArgumentException("holder is mandatory"); } MetadataSpiUtils.validateOptions(options); final Class<Item> itemClass = (Class<Item>)holder.get().getClass(); final MetadataItemProvider<Item> metadataProvider = (MetadataItemProvider<Item>)providerMapByClass.get(itemClass); if (metadataProvider == null) { throw new NoSuchMetadataTypeException(itemClass); } return metadataProvider.storeItem(getDataObject(), holder, options); }
@Test public void testInitialization() { logger.info("******** testInitialization()"); assertEquals(2, MetadataImpl.providerMapByClass.size()); assertEquals(3, MetadataImpl.interceptors.size()); assertTrue(MetadataImpl.providerMapByClass.get(MockItem1.class) instanceof MetadataItemProviderMock1); assertTrue(MetadataImpl.providerMapByClass.get(MockItem2.class) instanceof MetadataItemProviderMock2); assertTrue(MetadataImpl.interceptors.get(0) instanceof MetadataItemInterceptorMock1a); assertTrue(MetadataImpl.interceptors.get(1) instanceof MetadataItemInterceptorMock1b); assertTrue(MetadataImpl.interceptors.get(2) instanceof MetadataItemInterceptorMock2a); }
@Test public void testFindMetatadaItemsWithNullOption() throws IOException { try { final MetadataItemProviderSupport mips = new MetadataItemProviderMock1(); //new MetadataItemProviderSupport<MockItem1>(MockItem1.class, ENHANCED) {}; final DataObject dataObject = createDataObject("xxx"); mips.findOrCreateItems(dataObject, null); fail("IllegalArgumentException expected"); } catch (IllegalArgumentException e) { // ok } }
/*************************************************************************** * * {@inheritDoc} * **************************************************************************/ @Nonnull @Override public Set<Class<?>> getItemClasses() { return new CopyOnWriteArraySet<Class<?>>(providerMapByClass.keySet()); }
public MetadataItemFormatImpl() { for (final MetadataItemFormatProvider<?> provider : Lookup.getDefault().lookupAll(MetadataItemFormatProvider.class)) { formatProviderMapByClass.put(provider.getItemClass(), provider); } }
@Nonnull public String getPropertyDisplayName (@Nonnull final Class<?> itemClass, @Nonnull final String propertyName) { final MetadataItemFormatProvider formatProvider = formatProviderMapByClass.get(itemClass); return (formatProvider != null) ? formatProvider.getDisplayName(propertyName) : propertyName; }
@Nonnull public String getItemDisplayName (@Nonnull final Class<?> itemClass) { final MetadataItemFormatProvider formatProvider = formatProviderMapByClass.get(itemClass); return (formatProvider != null) ? formatProvider.getItemDisplayName() : itemClass.getSimpleName(); }
@Nonnull private Format findFormat (@Nonnull final Class<?> itemClass, @Nonnull final String propertyName) { logger.fine("findFormat(%s, %s", itemClass, propertyName); final MetadataItemFormatProvider formatProvider = formatProviderMapByClass.get(itemClass); final Format result = (formatProvider != null) ? formatProvider.getFormat(propertyName) : DEFAULT_FORMAT; logger.finer(">>>> returning %s", result); return result; } }
@Test public void testFindMetatadaItemsWithNullDataObject() { try { final MetadataItemProviderSupport mips = new MetadataItemProviderMock1(); // final MetadataItemProviderSupport mips = new MetadataItemProviderSupport<MockItem1>(MockItem1.class, ENHANCED) {}; mips.findOrCreateItems(null); fail("IllegalArgumentException expected"); } catch (IllegalArgumentException e) { // ok } }
@Before public void setUp() { enhancedItem = MetadataItemEnhancer.createEnhancedItem(new CompositeMockItem()); item = new MockItem1(); }
public Collection<? extends MetadataItemHolder<MockItem1>> loadMetadataItems (final DataObject dataObject, final FindOption ... options) { return Collections.singletonList(new MetadataItemHolderMock<MockItem1>(MetadataItemEnhancer.createEnhancedItem(new MockItem1(), DATE), getName(), "Mock", DATE)); } }
public Collection<? extends MetadataItemHolder<MockItem1>> loadMetadataItems (final DataObject dataObject, final FindOption ... options) { return Collections.singleton(new MetadataItemHolderMock<MockItem1>(MetadataItemEnhancer.createEnhancedItem(new MockItem1(), DATE), getName(), "Mock", DATE)); } }
public Collection<? extends MetadataItemHolder<MockItem1>> loadMetadataItems (final DataObject dataObject, final FindOption ... options) { return Collections.singletonList(new MetadataItemHolderMock<MockItem1>(MetadataItemEnhancer.createEnhancedItem(new MockItem1(), DATE), getName(), "Mock", DATE)); } }
@Test public void testAvailablePropertiesFixedByEnhancer() { item.setName("the name"); assertEquals("the name", item.getName()); assertFalse(item.isNameAvailable()); assertFalse(item.isAvailable()); MetadataItemEnhancer.createEnhancedItem(item); assertEquals("the name", item.getName()); assertTrue(item.isNameAvailable()); assertTrue(item.isAvailable()); }