Java tutorial
/* * Copyright 2011 Instituto Superior Tecnico * * https://fenix-ashes.ist.utl.pt/ * * This file is part of the vaadin-framework. * * The vaadin-framework Infrastructure is free software: you can * redistribute it and/or modify it under the terms of the GNU Lesser General * Public License as published by the Free Software Foundation, either version * 3 of the License, or (at your option) any later version.* * * vaadin-framework is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with vaadin-framework. If not, see <http://www.gnu.org/licenses/>. * */ package pt.ist.vaadinframework.data; import java.lang.reflect.Method; import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; import java.util.Collections; import java.util.EventObject; import java.util.HashMap; import java.util.LinkedList; import org.apache.commons.lang.StringUtils; import pt.ist.fenixWebFramework.services.ServiceManager; import pt.ist.fenixWebFramework.services.ServicePredicate; import pt.ist.vaadinframework.data.util.ServiceUtils; import com.vaadin.data.Buffered; import com.vaadin.data.BufferedValidatable; import com.vaadin.data.Item; import com.vaadin.data.Property; import com.vaadin.data.Validatable; import com.vaadin.data.Validator.InvalidValueException; public abstract class AbstractBufferedItem<Id, Type> extends BufferedProperty<Type> implements Item, Item.PropertySetChangeNotifier { private final LinkedList<Id> list = new LinkedList<Id>(); private final HashMap<Id, Property> map = new HashMap<Id, Property>(); private ItemConstructor<Id> constructor; private ItemWriter<Id> writer; private LinkedList<Item.PropertySetChangeListener> propertySetChangeListeners = null; private boolean propertySetChangePropagationEnabled = true; private Item.PropertySetChangeEvent lastEvent; public AbstractBufferedItem(Property wrapped, Hint... hints) { super(wrapped, hints); } public AbstractBufferedItem(Class<? extends Type> type, Hint... hints) { super(type, hints); } public AbstractBufferedItem(Type value, Hint... hints) { super(value, hints); } public AbstractBufferedItem(Type value, Class<? extends Type> type, Hint... hints) { super(value, type, hints); } @Override protected void processNewCacheValue() { for (Id propertyId : getItemPropertyIds()) { if (getItemProperty(propertyId) instanceof Buffered) { ((Buffered) getItemProperty(propertyId)).discard(); } } } @Override public boolean addItemProperty(Object propertyId, Property property) { // Null ids are not accepted if (propertyId == null) { throw new NullPointerException("Item property id can not be null"); } // Cant add a property twice if (map.containsKey(propertyId)) { return false; } // Put the property to map map.put((Id) propertyId, property); list.add((Id) propertyId); // Send event fireItemPropertySetChange(); return true; } @Override public boolean removeItemProperty(Object propertyId) { // Cant remove missing properties if (map.remove(propertyId) == null) { return false; } list.remove(propertyId); // propertyValues.remove(propertyId); // Send change events fireItemPropertySetChange(); return true; } @Override public Collection<Id> getItemPropertyIds() { return list != null ? Collections.unmodifiableCollection(list) : (Collection<Id>) Collections.emptyList(); } public void setConstructor(ItemConstructor<Id> constructor) { this.constructor = constructor; } public void setWriter(ItemWriter<Id> writer) { this.writer = writer; } @Override public Property getItemProperty(Object propertyId) { Property property = map.get(propertyId); if (property == null) { property = makeProperty((Id) propertyId); } return property; } /** * Lazy creation of properties, this method is invoked for every propertyId * that is requested of the Item. The created properties are not * automatically registered in the item, you have to invoke {@link #addItemProperty(Object, Property)} yourself. You also need * to * ensure that the returned properties are of {@link BufferedProperty}s or {@link Item}s or {@link Collection}s over * {@link BufferedProperty}s. * * @param propertyId * The key of the property. * @return A {@link Property} instance. */ protected abstract Property makeProperty(Id propertyId); @Override public void commit() throws SourceException, InvalidValueException { ServiceManager.execute(new ServicePredicate() { @Override public void execute() { try { if (!isInvalidCommitted() && !isValid()) { validate(); } if (cache == null) { construct(true); fireValueChange(); } else { applyWriter(); } for (Id propertyId : getItemPropertyIds()) { if (getItemProperty(propertyId) instanceof Buffered) { ((Buffered) getItemProperty(propertyId)).commit(); } } if (isModified()) { wrapped.setValue(cache); } discard(); modified = false; } catch (Throwable e) { ServiceUtils.handleException(e); throw new SourceException(AbstractBufferedItem.this, e); } } }); } private void construct(boolean taint) { Object value; if (constructor != null) { try { Method method = findMethod(constructor.getClass(), getArgumentTypes(constructor.getOrderedArguments())); Object[] argumentValues = readArguments(constructor.getOrderedArguments()); value = method.invoke(constructor, argumentValues); } catch (Throwable e) { ServiceUtils.handleException(e); throw new SourceException(this, e); } } else { try { value = getType().newInstance(); } catch (Throwable e) { ServiceUtils.handleException(e); throw new SourceException(this, e); } } cache = convertValue(value); modified = taint; } private void applyWriter() { if (writer != null) { try { if (fieldDiffer(writer.getOrderedArguments())) { LinkedList<Class<?>> argumentTypes = new LinkedList<Class<?>>(); argumentTypes.add(getType()); argumentTypes.addAll(Arrays.asList(getArgumentTypes(writer.getOrderedArguments()))); Method method = findMethod(writer.getClass(), argumentTypes.toArray(new Class<?>[0])); LinkedList<Object> argumentValues = new LinkedList<Object>(); argumentValues.add(cache); argumentValues.addAll(Arrays.asList(readArguments(writer.getOrderedArguments()))); // VaadinFrameworkLogger.getLogger().debug( // "persisting item with writer with properties: [" // + StringUtils.join(writer.getOrderedArguments(), ", ") + // "] with values: [" // + StringUtils.join(argumentValues.subList(1, // argumentValues.size()), ", ") + "]"); method.invoke(writer, argumentValues.toArray(new Object[0])); for (Id id : writer.getOrderedArguments()) { if (getItemProperty(id) instanceof Buffered) { ((Buffered) getItemProperty(id)).discard(); } } } } catch (Throwable e) { ServiceUtils.handleException(e); throw new SourceException(this, e); } } } private ArrayList<Throwable> getAllCauses(Throwable t) { final ArrayList<Throwable> causes = new ArrayList<Throwable>(); causes.add(t); if (t instanceof Buffered.SourceException) { for (Throwable sec : ((Buffered.SourceException) t).getCauses()) { causes.addAll(getAllCauses(sec)); } } else { if (t.getCause() != null) { causes.addAll(getAllCauses(t.getCause())); } } return causes; } // private Buffered.SourceException // handleDomainException(Buffered.SourceException se) { // final ArrayList<Throwable> causes = new ArrayList<Throwable>(); // for (Throwable throwable : getAllCauses(se)) { // if (throwable instanceof FFDomainException) { // return new Buffered.SourceException(se.getSource(), // new Throwable[] { new DomainExceptionErrorMessage(throwable) }); // } // causes.add(throwable); // } // return new Buffered.SourceException(se.getSource(), causes.toArray(new // Throwable[0])); // } private boolean fieldDiffer(Id[] arguments) { for (Id propertyId : arguments) { if (getItemProperty(propertyId) instanceof Buffered) { if (((Buffered) getItemProperty(propertyId)).isModified()) { return true; } } else { return true; } } return false; } private Method findMethod(Class<?> type, Class<?>[] types) throws NoSuchMethodException { for (Method method : type.getMethods()) { Class<?>[] mTypes = method.getParameterTypes(); boolean match = true; for (int i = 0; i < types.length; i++) { if (i >= mTypes.length) { match = false; break; } if (!mTypes[i].isAssignableFrom(Object.class) && !mTypes[i].isAssignableFrom(types[i])) { match = false; break; } } if (!getType().isAssignableFrom(method.getReturnType())) { match = false; } if (match) { return method; } } final String message = "Must specify a method in class %s with a signature compatible with the arguments in getOrderedArguments() [%s]"; throw new NoSuchMethodException(String.format(message, type.getName(), StringUtils.join(types, ","))); } private Class<?>[] getArgumentTypes(Id[] argumentIds) { Class<?>[] types = new Class<?>[argumentIds.length]; for (int i = 0; i < argumentIds.length; i++) { types[i] = getItemProperty(argumentIds[i]).getType(); } return types; } private Object[] readArguments(Id[] argumentIds) { Object[] arguments = new Object[argumentIds.length]; for (int i = 0; i < argumentIds.length; i++) { if (getItemProperty(argumentIds[i]) instanceof AbstractBufferedItem) { ((AbstractBufferedItem<?, ?>) getItemProperty(argumentIds[i])).construct(false); } arguments[i] = getItemProperty(argumentIds[i]).getValue(); } return arguments; } @Override public void discard() throws SourceException { super.discard(); for (Id propertyId : getItemPropertyIds()) { if (getItemProperty(propertyId) instanceof Buffered) { ((Buffered) getItemProperty(propertyId)).discard(); } } } @Override public void setWriteThrough(boolean writeThrough) throws SourceException, InvalidValueException { for (Id propertyId : getItemPropertyIds()) { if (getItemProperty(propertyId) instanceof Buffered) { ((Buffered) getItemProperty(propertyId)).setWriteThrough(writeThrough); } } super.setWriteThrough(writeThrough); } @Override public void setReadThrough(boolean readThrough) throws SourceException { for (Id propertyId : getItemPropertyIds()) { if (getItemProperty(propertyId) instanceof Buffered) { ((Buffered) getItemProperty(propertyId)).setReadThrough(readThrough); } } super.setReadThrough(readThrough); } @Override public void setInvalidAllowed(boolean invalidAllowed) throws UnsupportedOperationException { for (Id propertyId : getItemPropertyIds()) { if (getItemProperty(propertyId) instanceof Validatable) { ((Validatable) getItemProperty(propertyId)).setInvalidAllowed(invalidAllowed); } } super.setInvalidAllowed(invalidAllowed); } @Override public void setInvalidCommitted(boolean invalidCommitted) { for (Id propertyId : getItemPropertyIds()) { if (getItemProperty(propertyId) instanceof BufferedValidatable) { ((BufferedValidatable) getItemProperty(propertyId)).setInvalidCommitted(invalidCommitted); } } super.setInvalidCommitted(invalidCommitted); } @Override public boolean isValid() { for (Id propertyId : getItemPropertyIds()) { if (getItemProperty(propertyId) instanceof Validatable) { if (!((Validatable) getItemProperty(propertyId)).isValid()) { return false; } } } return super.isValid(); } @Override public void validate() throws InvalidValueException { for (Id propertyId : getItemPropertyIds()) { if (getItemProperty(propertyId) instanceof Validatable) { ((Validatable) getItemProperty(propertyId)).validate(); } } super.validate(); } /* Notifiers */ private class PropertySetChangeEvent extends EventObject implements Item.PropertySetChangeEvent { private PropertySetChangeEvent(Item source) { super(source); } /** * Gets the Item whose Property set has changed. * * @return source object of the event as an <code>Item</code> */ @Override public Item getItem() { return (Item) getSource(); } } /** * Registers a new property set change listener for this Item. * * @param listener * the new Listener to be registered. */ @Override public void addListener(Item.PropertySetChangeListener listener) { if (propertySetChangeListeners == null) { propertySetChangeListeners = new LinkedList<PropertySetChangeListener>(); } propertySetChangeListeners.add(listener); } /** * Removes a previously registered property set change listener. * * @param listener * the Listener to be removed. */ @Override public void removeListener(Item.PropertySetChangeListener listener) { if (propertySetChangeListeners != null) { propertySetChangeListeners.remove(listener); } } /** * Sends a Property set change event to all interested listeners. */ protected void fireItemPropertySetChange() { if (propertySetChangeListeners != null) { final Item.PropertySetChangeEvent event = new AbstractBufferedItem.PropertySetChangeEvent(this); if (propertySetChangePropagationEnabled) { final Object[] l = propertySetChangeListeners.toArray(); for (Object element : l) { ((Item.PropertySetChangeListener) element).itemPropertySetChange(event); } } else { lastEvent = event; } } } public void setPropertySetChangePropagationEnabled(boolean propertySetChangePropagationEnabled) { if (this.propertySetChangePropagationEnabled != propertySetChangePropagationEnabled) { this.propertySetChangePropagationEnabled = propertySetChangePropagationEnabled; if (propertySetChangePropagationEnabled && lastEvent != null) { if (propertySetChangeListeners != null) { final Object[] l = propertySetChangeListeners.toArray(); for (Object element : l) { ((Item.PropertySetChangeListener) element).itemPropertySetChange(lastEvent); } } lastEvent = null; } } } @Override public Collection<?> getListeners(Class<?> eventType) { if (Item.PropertySetChangeEvent.class.isAssignableFrom(eventType)) { if (propertySetChangeListeners == null) { return Collections.EMPTY_LIST; } return Collections.unmodifiableCollection(propertySetChangeListeners); } return Collections.EMPTY_LIST; } }