Add Java 6 @Override annotations to all methods from interfaces

src/com/vaadin/data/Container.java

          * @return <code>true</code> if the operation succeeded,
          *         <code>false</code> if not
          */
+        @Override
         public boolean removeItem(Object itemId)
                 throws UnsupportedOperationException;
     }

src/com/vaadin/data/fieldgroup/DefaultFieldGroupFieldFactory.java

 
     public static final Object CAPTION_PROPERTY_ID = "Caption";
 
+    @Override
     public <T extends Field> T createField(Class<?> type, Class<T> fieldType) {
         if (Enum.class.isAssignableFrom(type)) {
             return createEnumField(type, fieldType);

src/com/vaadin/data/util/AbstractBeanContainer.java

             this.propertyId = propertyId;
         }
 
+        @Override
         @SuppressWarnings("unchecked")
         public IDTYPE getIdForBean(BEANTYPE bean)
                 throws IllegalArgumentException {
      * 
      * @see com.vaadin.data.Container#getType(java.lang.Object)
      */
+    @Override
     public Class<?> getType(Object propertyId) {
         return model.get(propertyId).getPropertyType();
     }
      * 
      * @see com.vaadin.data.Container#getContainerPropertyIds()
      */
+    @Override
     public Collection<String> getContainerPropertyIds() {
         return model.keySet();
     }
      * @see com.vaadin.data.Container#getContainerProperty(java.lang.Object,
      * java.lang.Object)
      */
+    @Override
     public Property<?> getContainerProperty(Object itemId, Object propertyId) {
         Item item = getItem(itemId);
         if (item == null) {
     /**
      * Re-filter the container when one of the monitored properties changes.
      */
+    @Override
     public void valueChange(ValueChangeEvent event) {
         // if a property that is used in a filter is changed, refresh filtering
         filterAll();
      * com.vaadin.data.Container.Filterable#addContainerFilter(java.lang.Object,
      * java.lang.String, boolean, boolean)
      */
+    @Override
     public void addContainerFilter(Object propertyId, String filterString,
             boolean ignoreCase, boolean onlyMatchPrefix) {
         try {
      * 
      * @see com.vaadin.data.Container.Filterable#removeAllContainerFilters()
      */
+    @Override
     public void removeAllContainerFilters() {
         if (!getFilters().isEmpty()) {
             for (Item item : itemIdToItem.values()) {
      * com.vaadin.data.Container.Filterable#removeContainerFilters(java.lang
      * .Object)
      */
+    @Override
     public void removeContainerFilters(Object propertyId) {
         Collection<Filter> removedFilters = super.removeFilters(propertyId);
         if (!removedFilters.isEmpty()) {
         }
     }
 
+    @Override
     public void addContainerFilter(Filter filter)
             throws UnsupportedFilterException {
         addFilter(filter);
     }
 
+    @Override
     public void removeContainerFilter(Filter filter) {
         removeFilter(filter);
     }
      * 
      * @see com.vaadin.data.Container.Sortable#getSortableContainerPropertyIds()
      */
+    @Override
     public Collection<?> getSortableContainerPropertyIds() {
         return getSortablePropertyIds();
     }
      * @see com.vaadin.data.Container.Sortable#sort(java.lang.Object[],
      * boolean[])
      */
+    @Override
     public void sort(Object[] propertyId, boolean[] ascending) {
         sortContainer(propertyId, ascending);
     }

src/com/vaadin/data/util/AbstractContainer.java

             super(source);
         }
 
+        @Override
         public Container getContainer() {
             return (Container) getSource();
         }
             super(source);
         }
 
+        @Override
         public Container getContainer() {
             return (Container) getSource();
         }

src/com/vaadin/data/util/AbstractInMemoryContainer.java

     // Container interface methods with more specific return class
 
     // default implementation, can be overridden
+    @Override
     public ITEMCLASS getItem(Object itemId) {
         if (containsId(itemId)) {
             return getUnfilteredItem(itemId);
 
     // Container interface method implementations
 
+    @Override
     public int size() {
         return getVisibleItemIds().size();
     }
 
+    @Override
     public boolean containsId(Object itemId) {
         // only look at visible items after filtering
         if (itemId == null) {
         }
     }
 
+    @Override
     public List<?> getItemIds() {
         return Collections.unmodifiableList(getVisibleItemIds());
     }
 
     // Container.Ordered
 
+    @Override
     public ITEMIDTYPE nextItemId(Object itemId) {
         int index = indexOfId(itemId);
         if (index >= 0 && index < size() - 1) {
         }
     }
 
+    @Override
     public ITEMIDTYPE prevItemId(Object itemId) {
         int index = indexOfId(itemId);
         if (index > 0) {
         }
     }
 
+    @Override
     public ITEMIDTYPE firstItemId() {
         if (size() > 0) {
             return getIdByIndex(0);
         }
     }
 
+    @Override
     public ITEMIDTYPE lastItemId() {
         if (size() > 0) {
             return getIdByIndex(size() - 1);
         }
     }
 
+    @Override
     public boolean isFirstId(Object itemId) {
         if (itemId == null) {
             return false;
         return itemId.equals(firstItemId());
     }
 
+    @Override
     public boolean isLastId(Object itemId) {
         if (itemId == null) {
             return false;
 
     // Container.Indexed
 
+    @Override
     public ITEMIDTYPE getIdByIndex(int index) {
         return getVisibleItemIds().get(index);
     }
 
+    @Override
     public int indexOfId(Object itemId) {
         return getVisibleItemIds().indexOf(itemId);
     }
 
     // methods that are unsupported by default, override to support
 
+    @Override
     public Object addItemAt(int index) throws UnsupportedOperationException {
         throw new UnsupportedOperationException(
                 "Adding items not supported. Override the relevant addItem*() methods if required as specified in AbstractInMemoryContainer javadoc.");
     }
 
+    @Override
     public Item addItemAt(int index, Object newItemId)
             throws UnsupportedOperationException {
         throw new UnsupportedOperationException(
                 "Adding items not supported. Override the relevant addItem*() methods if required as specified in AbstractInMemoryContainer javadoc.");
     }
 
+    @Override
     public Object addItemAfter(Object previousItemId)
             throws UnsupportedOperationException {
         throw new UnsupportedOperationException(
                 "Adding items not supported. Override the relevant addItem*() methods if required as specified in AbstractInMemoryContainer javadoc.");
     }
 
+    @Override
     public Item addItemAfter(Object previousItemId, Object newItemId)
             throws UnsupportedOperationException {
         throw new UnsupportedOperationException(
                 "Adding items not supported. Override the relevant addItem*() methods if required as specified in AbstractInMemoryContainer javadoc.");
     }
 
+    @Override
     public Item addItem(Object itemId) throws UnsupportedOperationException {
         throw new UnsupportedOperationException(
                 "Adding items not supported. Override the relevant addItem*() methods if required as specified in AbstractInMemoryContainer javadoc.");
     }
 
+    @Override
     public Object addItem() throws UnsupportedOperationException {
         throw new UnsupportedOperationException(
                 "Adding items not supported. Override the relevant addItem*() methods if required as specified in AbstractInMemoryContainer javadoc.");
     }
 
+    @Override
     public boolean removeItem(Object itemId)
             throws UnsupportedOperationException {
         throw new UnsupportedOperationException(
                 "Removing items not supported. Override the removeItem() method if required as specified in AbstractInMemoryContainer javadoc.");
     }
 
+    @Override
     public boolean removeAllItems() throws UnsupportedOperationException {
         throw new UnsupportedOperationException(
                 "Removing items not supported. Override the removeAllItems() method if required as specified in AbstractInMemoryContainer javadoc.");
     }
 
+    @Override
     public boolean addContainerProperty(Object propertyId, Class<?> type,
             Object defaultValue) throws UnsupportedOperationException {
         throw new UnsupportedOperationException(
                 "Adding container properties not supported. Override the addContainerProperty() method if required.");
     }
 
+    @Override
     public boolean removeContainerProperty(Object propertyId)
             throws UnsupportedOperationException {
         throw new UnsupportedOperationException(

src/com/vaadin/data/util/AbstractProperty.java

      * Override for additional restrictions on what is considered a read-only
      * property.
      */
+    @Override
     public boolean isReadOnly() {
         return readOnly;
     }
 
+    @Override
     public void setReadOnly(boolean newStatus) {
         boolean oldStatus = isReadOnly();
         readOnly = newStatus;
          * 
          * @return source Property of the event.
          */
+        @Override
         public Property getProperty() {
             return (Property) getSource();
         }
      * @param listener
      *            the new Listener to be registered.
      */
+    @Override
     public void addListener(Property.ReadOnlyStatusChangeListener listener) {
         if (readOnlyStatusChangeListeners == null) {
             readOnlyStatusChangeListeners = new LinkedList<ReadOnlyStatusChangeListener>();
      * @param listener
      *            the listener to be removed.
      */
+    @Override
     public void removeListener(Property.ReadOnlyStatusChangeListener listener) {
         if (readOnlyStatusChangeListeners != null) {
             readOnlyStatusChangeListeners.remove(listener);
          * 
          * @return source Property of the event.
          */
+        @Override
         public Property getProperty() {
             return (Property) getSource();
         }
 
     }
 
+    @Override
     public void addListener(ValueChangeListener listener) {
         if (valueChangeListeners == null) {
             valueChangeListeners = new LinkedList<ValueChangeListener>();
 
     }
 
+    @Override
     public void removeListener(ValueChangeListener listener) {
         if (valueChangeListeners != null) {
             valueChangeListeners.remove(listener);

src/com/vaadin/data/util/BeanItemContainer.java

     private static class IdentityBeanIdResolver<BT> implements
             BeanIdResolver<BT, BT> {
 
+        @Override
         public BT getIdForBean(BT bean) {
             return bean;
         }

src/com/vaadin/data/util/ContainerHierarchicalWrapper.java

             this.itemIds = itemIds;
         }
 
+        @Override
         public int compare(Object o1, Object o2) {
             if (o1.equals(o2)) {
                 return 0;
      * Can the specified Item have any children? Don't add a JavaDoc comment
      * here, we use the default documentation from implemented interface.
      */
+    @Override
     public boolean areChildrenAllowed(Object itemId) {
 
         // If the wrapped container implements the method directly, use it
      * comment here, we use the default documentation from implemented
      * interface.
      */
+    @Override
     public Collection<?> getChildren(Object itemId) {
 
         // If the wrapped container implements the method directly, use it
      * comment here, we use the default documentation from implemented
      * interface.
      */
+    @Override
     public Object getParent(Object itemId) {
 
         // If the wrapped container implements the method directly, use it
      * JavaDoc comment here, we use the default documentation from implemented
      * interface.
      */
+    @Override
     public boolean hasChildren(Object itemId) {
 
         // If the wrapped container implements the method directly, use it
      * JavaDoc comment here, we use the default documentation from implemented
      * interface.
      */
+    @Override
     public boolean isRoot(Object itemId) {
 
         // If the wrapped container implements the method directly, use it
      * comment here, we use the default documentation from implemented
      * interface.
      */
+    @Override
     public Collection<?> rootItemIds() {
 
         // If the wrapped container implements the method directly, use it
      * @return <code>true</code> if the operation succeeded, <code>false</code>
      *         if not
      */
+    @Override
     public boolean setChildrenAllowed(Object itemId, boolean childrenAllowed) {
 
         // If the wrapped container implements the method directly, use it
      * @return <code>true</code> if the operation succeeded, <code>false</code>
      *         if not
      */
+    @Override
     public boolean setParent(Object itemId, Object newParentId) {
 
         // If the wrapped container implements the method directly, use it
      * @throws UnsupportedOperationException
      *             if the addItem is not supported.
      */
+    @Override
     public Object addItem() throws UnsupportedOperationException {
 
         final Object id = container.addItem();
      * @throws UnsupportedOperationException
      *             if the addItem is not supported.
      */
+    @Override
     public Item addItem(Object itemId) throws UnsupportedOperationException {
 
         // Null ids are not accepted
      * @throws UnsupportedOperationException
      *             if the removeAllItems is not supported.
      */
+    @Override
     public boolean removeAllItems() throws UnsupportedOperationException {
 
         final boolean success = container.removeAllItems();
      * @throws UnsupportedOperationException
      *             if the removeItem is not supported.
      */
+    @Override
     public boolean removeItem(Object itemId)
             throws UnsupportedOperationException {
 
      * @throws UnsupportedOperationException
      *             if the addContainerProperty is not supported.
      */
+    @Override
     public boolean addContainerProperty(Object propertyId, Class<?> type,
             Object defaultValue) throws UnsupportedOperationException {
 
      * @throws UnsupportedOperationException
      *             if the removeContainerProperty is not supported.
      */
+    @Override
     public boolean removeContainerProperty(Object propertyId)
             throws UnsupportedOperationException {
         return container.removeContainerProperty(propertyId);
      * comment here, we use the default documentation from implemented
      * interface.
      */
+    @Override
     public boolean containsId(Object itemId) {
         return container.containsId(itemId);
     }
      * Gets the specified Item from the container. Don't add a JavaDoc comment
      * here, we use the default documentation from implemented interface.
      */
+    @Override
     public Item getItem(Object itemId) {
         return container.getItem(itemId);
     }
      * comment here, we use the default documentation from implemented
      * interface.
      */
+    @Override
     public Collection<?> getItemIds() {
         return container.getItemIds();
     }
      * Container Don't add a JavaDoc comment here, we use the default
      * documentation from implemented interface.
      */
+    @Override
     public Property<?> getContainerProperty(Object itemId, Object propertyId) {
         return container.getContainerProperty(itemId, propertyId);
     }
      * JavaDoc comment here, we use the default documentation from implemented
      * interface.
      */
+    @Override
     public Collection<?> getContainerPropertyIds() {
         return container.getContainerPropertyIds();
     }
      * Don't add a JavaDoc comment here, we use the default documentation from
      * implemented interface.
      */
+    @Override
     public Class<?> getType(Object propertyId) {
         return container.getType(propertyId);
     }
      * Gets the number of Items in the Container. Don't add a JavaDoc comment
      * here, we use the default documentation from implemented interface.
      */
+    @Override
     public int size() {
         return container.size();
     }
      * JavaDoc comment here, we use the default documentation from implemented
      * interface.
      */
+    @Override
     public void addListener(Container.ItemSetChangeListener listener) {
         if (container instanceof Container.ItemSetChangeNotifier) {
             ((Container.ItemSetChangeNotifier) container)
      * comment here, we use the default documentation from implemented
      * interface.
      */
+    @Override
     public void removeListener(Container.ItemSetChangeListener listener) {
         if (container instanceof Container.ItemSetChangeNotifier) {
             ((Container.ItemSetChangeNotifier) container)
      * add a JavaDoc comment here, we use the default documentation from
      * implemented interface.
      */
+    @Override
     public void addListener(Container.PropertySetChangeListener listener) {
         if (container instanceof Container.PropertySetChangeNotifier) {
             ((Container.PropertySetChangeNotifier) container)
      * JavaDoc comment here, we use the default documentation from implemented
      * interface.
      */
+    @Override
     public void removeListener(Container.PropertySetChangeListener listener) {
         if (container instanceof Container.PropertySetChangeNotifier) {
             ((Container.PropertySetChangeNotifier) container)
             listener = realListener;
         }
 
+        @Override
         public void containerItemSetChange(ItemSetChangeEvent event) {
             updateHierarchicalWrapper();
             ((Container.ItemSetChangeListener) listener)
 
         }
 
+        @Override
         public void containerPropertySetChange(PropertySetChangeEvent event) {
             updateHierarchicalWrapper();
             ((Container.PropertySetChangeListener) listener)

src/com/vaadin/data/util/ContainerOrderedWrapper.java

      * comment here, we use the default documentation from implemented
      * interface.
      */
+    @Override
     public Object firstItemId() {
         if (ordered) {
             return ((Container.Ordered) container).firstItemId();
      * JavaDoc comment here, we use the default documentation from implemented
      * interface.
      */
+    @Override
     public boolean isFirstId(Object itemId) {
         if (ordered) {
             return ((Container.Ordered) container).isFirstId(itemId);
      * JavaDoc comment here, we use the default documentation from implemented
      * interface.
      */
+    @Override
     public boolean isLastId(Object itemId) {
         if (ordered) {
             return ((Container.Ordered) container).isLastId(itemId);
      * comment here, we use the default documentation from implemented
      * interface.
      */
+    @Override
     public Object lastItemId() {
         if (ordered) {
             return ((Container.Ordered) container).lastItemId();
      * comment here, we use the default documentation from implemented
      * interface.
      */
+    @Override
     public Object nextItemId(Object itemId) {
         if (ordered) {
             return ((Container.Ordered) container).nextItemId(itemId);
      * JavaDoc comment here, we use the default documentation from implemented
      * interface.
      */
+    @Override
     public Object prevItemId(Object itemId) {
         if (ordered) {
             return ((Container.Ordered) container).prevItemId(itemId);
      * @return <code>true</code> if the operation succeeded, <code>false</code>
      *         if not
      */
+    @Override
     public boolean addContainerProperty(Object propertyId, Class<?> type,
             Object defaultValue) throws UnsupportedOperationException {
 
      * @throws UnsupportedOperationException
      *             if the addItem is not supported.
      */
+    @Override
     public Object addItem() throws UnsupportedOperationException {
 
         final Object id = container.addItem();
      * @throws UnsupportedOperationException
      *             if the addItem is not supported.
      */
+    @Override
     public Item addItem(Object itemId) throws UnsupportedOperationException {
         final Item item = container.addItem(itemId);
         if (!ordered && item != null) {
      * @throws UnsupportedOperationException
      *             if the removeAllItems is not supported.
      */
+    @Override
     public boolean removeAllItems() throws UnsupportedOperationException {
         final boolean success = container.removeAllItems();
         if (!ordered && success) {
      * @throws UnsupportedOperationException
      *             if the removeItem is not supported.
      */
+    @Override
     public boolean removeItem(Object itemId)
             throws UnsupportedOperationException {
 
      * @throws UnsupportedOperationException
      *             if the removeContainerProperty is not supported.
      */
+    @Override
     public boolean removeContainerProperty(Object propertyId)
             throws UnsupportedOperationException {
         return container.removeContainerProperty(propertyId);
      * comment here, we use the default documentation from implemented
      * interface.
      */
+    @Override
     public boolean containsId(Object itemId) {
         return container.containsId(itemId);
     }
      * Gets the specified Item from the container. Don't add a JavaDoc comment
      * here, we use the default documentation from implemented interface.
      */
+    @Override
     public Item getItem(Object itemId) {
         return container.getItem(itemId);
     }
      * comment here, we use the default documentation from implemented
      * interface.
      */
+    @Override
     public Collection<?> getItemIds() {
         return container.getItemIds();
     }
      * Container Don't add a JavaDoc comment here, we use the default
      * documentation from implemented interface.
      */
+    @Override
     public Property<?> getContainerProperty(Object itemId, Object propertyId) {
         return container.getContainerProperty(itemId, propertyId);
     }
      * JavaDoc comment here, we use the default documentation from implemented
      * interface.
      */
+    @Override
     public Collection<?> getContainerPropertyIds() {
         return container.getContainerPropertyIds();
     }
      * Don't add a JavaDoc comment here, we use the default documentation from
      * implemented interface.
      */
+    @Override
     public Class<?> getType(Object propertyId) {
         return container.getType(propertyId);
     }
      * Gets the number of Items in the Container. Don't add a JavaDoc comment
      * here, we use the default documentation from implemented interface.
      */
+    @Override
     public int size() {
         int newSize = container.size();
         if (lastKnownSize != -1 && newSize != lastKnownSize
      * JavaDoc comment here, we use the default documentation from implemented
      * interface.
      */
+    @Override
     public void addListener(Container.ItemSetChangeListener listener) {
         if (container instanceof Container.ItemSetChangeNotifier) {
             ((Container.ItemSetChangeNotifier) container)
      * comment here, we use the default documentation from implemented
      * interface.
      */
+    @Override
     public void removeListener(Container.ItemSetChangeListener listener) {
         if (container instanceof Container.ItemSetChangeNotifier) {
             ((Container.ItemSetChangeNotifier) container)
      * add a JavaDoc comment here, we use the default documentation from
      * implemented interface.
      */
+    @Override
     public void addListener(Container.PropertySetChangeListener listener) {
         if (container instanceof Container.PropertySetChangeNotifier) {
             ((Container.PropertySetChangeNotifier) container)
      * JavaDoc comment here, we use the default documentation from implemented
      * interface.
      */
+    @Override
     public void removeListener(Container.PropertySetChangeListener listener) {
         if (container instanceof Container.PropertySetChangeNotifier) {
             ((Container.PropertySetChangeNotifier) container)
      * @see com.vaadin.data.Container.Ordered#addItemAfter(java.lang.Object,
      * java.lang.Object)
      */
+    @Override
     public Item addItemAfter(Object previousItemId, Object newItemId)
             throws UnsupportedOperationException {
 
      * 
      * @see com.vaadin.data.Container.Ordered#addItemAfter(java.lang.Object)
      */
+    @Override
     public Object addItemAfter(Object previousItemId)
             throws UnsupportedOperationException {
 
             listener = realListener;
         }
 
+        @Override
         public void containerItemSetChange(ItemSetChangeEvent event) {
             updateOrderWrapper();
             ((Container.ItemSetChangeListener) listener)
 
         }
 
+        @Override
         public void containerPropertySetChange(PropertySetChangeEvent event) {
             updateOrderWrapper();
             ((Container.PropertySetChangeListener) listener)

src/com/vaadin/data/util/DefaultItemSorter.java

      * @see com.vaadin.data.util.ItemSorter#compare(java.lang.Object,
      * java.lang.Object)
      */
+    @Override
     public int compare(Object o1, Object o2) {
         Item item1 = container.getItem(o1);
         Item item2 = container.getItem(o2);
      * com.vaadin.data.util.ItemSorter#setSortProperties(com.vaadin.data.Container
      * .Sortable, java.lang.Object[], boolean[])
      */
+    @Override
     public void setSortProperties(Container.Sortable container,
             Object[] propertyId, boolean[] ascending) {
         this.container = container;
     public static class DefaultPropertyValueComparator implements
             Comparator<Object>, Serializable {
 
+        @Override
         @SuppressWarnings("unchecked")
         public int compare(Object o1, Object o2) {
             int r = 0;

src/com/vaadin/data/util/FilesystemContainer.java

      * @return <code>true</code> if the specified Item is a directory,
      *         <code>false</code> otherwise.
      */
+    @Override
     public boolean areChildrenAllowed(Object itemId) {
         return itemId instanceof File && ((File) itemId).canRead()
                 && ((File) itemId).isDirectory();
      * add a JavaDoc comment here, we use the default documentation from
      * implemented interface.
      */
+    @Override
     public Collection<File> getChildren(Object itemId) {
 
         if (!(itemId instanceof File)) {
      * Gets the parent item of the specified Item. Don't add a JavaDoc comment
      * here, we use the default documentation from implemented interface.
      */
+    @Override
     public Object getParent(Object itemId) {
 
         if (!(itemId instanceof File)) {
      * Tests if the specified Item has any children. Don't add a JavaDoc comment
      * here, we use the default documentation from implemented interface.
      */
+    @Override
     public boolean hasChildren(Object itemId) {
 
         if (!(itemId instanceof File)) {
      * JavaDoc comment here, we use the default documentation from implemented
      * interface.
      */
+    @Override
     public boolean isRoot(Object itemId) {
 
         if (!(itemId instanceof File)) {
      * comment here, we use the default documentation from implemented
      * interface.
      */
+    @Override
     public Collection<File> rootItemIds() {
 
         File[] f;
      * @throws UnsupportedOperationException
      *             if the setChildrenAllowed is not supported.
      */
+    @Override
     public boolean setChildrenAllowed(Object itemId, boolean areChildrenAllowed)
             throws UnsupportedOperationException {
 
      * @throws UnsupportedOperationException
      *             if the setParent is not supported.
      */
+    @Override
     public boolean setParent(Object itemId, Object newParentId)
             throws UnsupportedOperationException {
 
      * comment here, we use the default documentation from implemented
      * interface.
      */
+    @Override
     public boolean containsId(Object itemId) {
 
         if (!(itemId instanceof File)) {
      * Gets the specified Item from the filesystem. Don't add a JavaDoc comment
      * here, we use the default documentation from implemented interface.
      */
+    @Override
     public Item getItem(Object itemId) {
 
         if (!(itemId instanceof File)) {
      * Gets the IDs of Items in the filesystem. Don't add a JavaDoc comment
      * here, we use the default documentation from implemented interface.
      */
+    @Override
     public Collection<File> getItemIds() {
 
         if (recursive) {
      *            the property's ID.
      * @return the requested property's value, or <code>null</code>
      */
+    @Override
     public Property<?> getContainerProperty(Object itemId, Object propertyId) {
 
         if (!(itemId instanceof File)) {
      * 
      * @return Unmodifiable collection containing all available file properties.
      */
+    @Override
     public Collection<String> getContainerPropertyIds() {
         return FILE_PROPERTIES;
     }
      *            the ID of the property whose type is requested.
      * @return data type of the requested property, or <code>null</code>
      */
+    @Override
     public Class<?> getType(Object propertyId) {
 
         if (propertyId.equals(PROPERTY_NAME)) {
      * 
      * @return Number of Items in the container.
      */
+    @Override
     public int size() {
 
         if (recursive) {
          * Gets the specified property of this file. Don't add a JavaDoc comment
          * here, we use the default documentation from implemented interface.
          */
+        @Override
         public Property<?> getItemProperty(Object id) {
             return getContainerProperty(file, id);
         }
          * JavaDoc comment here, we use the default documentation from
          * implemented interface.
          */
+        @Override
         public Collection<String> getItemPropertyIds() {
             return getContainerPropertyIds();
         }
          * 
          * @see com.vaadin.data.Item#addItemProperty(Object, Property)
          */
+        @Override
         public boolean addItemProperty(Object id, Property property)
                 throws UnsupportedOperationException {
             throw new UnsupportedOperationException("Filesystem container "
          * 
          * @see com.vaadin.data.Item#removeItemProperty(Object)
          */
+        @Override
         public boolean removeItemProperty(Object id)
                 throws UnsupportedOperationException {
             throw new UnsupportedOperationException(
          * 
          * @see java.io.FilenameFilter#accept(File, String)
          */
+        @Override
         public boolean accept(File dir, String name) {
             if (name.endsWith(filter)) {
                 return true;
      * @see com.vaadin.data.Container#addContainerProperty(java.lang.Object,
      * java.lang.Class, java.lang.Object)
      */
+    @Override
     public boolean addContainerProperty(Object propertyId, Class<?> type,
             Object defaultValue) throws UnsupportedOperationException {
         throw new UnsupportedOperationException(
      * 
      * @see com.vaadin.data.Container#addItem()
      */
+    @Override
     public Object addItem() throws UnsupportedOperationException {
         throw new UnsupportedOperationException(
                 "File system container does not support this operation");
      * 
      * @see com.vaadin.data.Container#addItem(java.lang.Object)
      */
+    @Override
     public Item addItem(Object itemId) throws UnsupportedOperationException {
         throw new UnsupportedOperationException(
                 "File system container does not support this operation");
      * 
      * @see com.vaadin.data.Container#removeAllItems()
      */
+    @Override
     public boolean removeAllItems() throws UnsupportedOperationException {
         throw new UnsupportedOperationException(
                 "File system container does not support this operation");
      * 
      * @see com.vaadin.data.Container#removeItem(java.lang.Object)
      */
+    @Override
     public boolean removeItem(Object itemId)
             throws UnsupportedOperationException {
         throw new UnsupportedOperationException(
      * 
      * @see com.vaadin.data.Container#removeContainerProperty(java.lang.Object )
      */
+    @Override
     public boolean removeContainerProperty(Object propertyId)
             throws UnsupportedOperationException {
         throw new UnsupportedOperationException(

src/com/vaadin/data/util/HierarchicalContainer.java

      * Can the specified Item have any children? Don't add a JavaDoc comment
      * here, we use the default documentation from implemented interface.
      */
+    @Override
     public boolean areChildrenAllowed(Object itemId) {
         if (noChildrenAllowed.contains(itemId)) {
             return false;
      * comment here, we use the default documentation from implemented
      * interface.
      */
+    @Override
     public Collection<?> getChildren(Object itemId) {
         LinkedList<Object> c;
 
      * comment here, we use the default documentation from implemented
      * interface.
      */
+    @Override
     public Object getParent(Object itemId) {
         if (filteredParent != null) {
             return filteredParent.get(itemId);
      * JavaDoc comment here, we use the default documentation from implemented
      * interface.
      */
+    @Override
     public boolean hasChildren(Object itemId) {
         if (filteredChildren != null) {
             return filteredChildren.containsKey(itemId);
      * JavaDoc comment here, we use the default documentation from implemented
      * interface.
      */
+    @Override
     public boolean isRoot(Object itemId) {
         // If the container is filtered the itemId must be among filteredRoots
         // to be a root.
      * comment here, we use the default documentation from implemented
      * interface.
      */
+    @Override
     public Collection<?> rootItemIds() {
         if (filteredRoots != null) {
             return Collections.unmodifiableCollection(filteredRoots);
      * @return <code>true</code> if the operation succeeded, <code>false</code>
      *         if not
      */
+    @Override
     public boolean setChildrenAllowed(Object itemId, boolean childrenAllowed) {
 
         // Checks that the item is in the container
      * @return <code>true</code> if the operation succeeded, <code>false</code>
      *         if not
      */
+    @Override
     public boolean setParent(Object itemId, Object newParentId) {
 
         // Checks that the item is in the container

src/com/vaadin/data/util/HierarchicalContainerOrderedWrapper.java

         hierarchical = toBeWrapped;
     }
 
+    @Override
     public boolean areChildrenAllowed(Object itemId) {
         return hierarchical.areChildrenAllowed(itemId);
     }
 
+    @Override
     public Collection<?> getChildren(Object itemId) {
         return hierarchical.getChildren(itemId);
     }
 
+    @Override
     public Object getParent(Object itemId) {
         return hierarchical.getParent(itemId);
     }
 
+    @Override
     public boolean hasChildren(Object itemId) {
         return hierarchical.hasChildren(itemId);
     }
 
+    @Override
     public boolean isRoot(Object itemId) {
         return hierarchical.isRoot(itemId);
     }
 
+    @Override
     public Collection<?> rootItemIds() {
         return hierarchical.rootItemIds();
     }
 
+    @Override
     public boolean setChildrenAllowed(Object itemId, boolean areChildrenAllowed)
             throws UnsupportedOperationException {
         return hierarchical.setChildrenAllowed(itemId, areChildrenAllowed);
     }
 
+    @Override
     public boolean setParent(Object itemId, Object newParentId)
             throws UnsupportedOperationException {
         return hierarchical.setParent(itemId, newParentId);

src/com/vaadin/data/util/IndexedContainer.java

      * 
      * @see com.vaadin.data.Container#getContainerPropertyIds()
      */
+    @Override
     public Collection<?> getContainerPropertyIds() {
         return Collections.unmodifiableCollection(propertyIds);
     }
      *            the ID of the Property.
      * @return Type of the requested Property
      */
+    @Override
     public Class<?> getType(Object propertyId) {
         return types.get(propertyId);
     }
      * @see com.vaadin.data.Container#getContainerProperty(java.lang.Object,
      * java.lang.Object)
      */
+    @Override
     public Property<?> getContainerProperty(Object itemId, Object propertyId) {
         if (!containsId(itemId)) {
             return null;
          * 
          * @see com.vaadin.data.Property.ValueChangeEvent#getProperty()
          */
+        @Override
         public Property getProperty() {
             return (Property) getSource();
         }
      * @see com.vaadin.data.Property.ValueChangeNotifier#addListener(com.
      * vaadin.data.Property.ValueChangeListener)
      */
+    @Override
     public void addListener(Property.ValueChangeListener listener) {
         if (propertyValueChangeListeners == null) {
             propertyValueChangeListeners = new LinkedList<Property.ValueChangeListener>();
      * @see com.vaadin.data.Property.ValueChangeNotifier#removeListener(com
      * .vaadin.data.Property.ValueChangeListener)
      */
+    @Override
     public void removeListener(Property.ValueChangeListener listener) {
         if (propertyValueChangeListeners != null) {
             propertyValueChangeListeners.remove(listener);
          * 
          * @see com.vaadin.data.Item#getItemProperty(java.lang.Object)
          */
+        @Override
         public Property<?> getItemProperty(Object id) {
             return new IndexedContainerProperty(itemId, id);
         }
 
+        @Override
         public Collection<?> getItemPropertyIds() {
             return Collections.unmodifiableCollection(propertyIds);
         }
          * 
          * @see com.vaadin.data.Item#addProperty(Object, Property)
          */
+        @Override
         public boolean addItemProperty(Object id, Property property)
                 throws UnsupportedOperationException {
             throw new UnsupportedOperationException("Indexed container item "
          * 
          * @see com.vaadin.data.Item#removeProperty(Object)
          */
+        @Override
         public boolean removeItemProperty(Object id)
                 throws UnsupportedOperationException {
             throw new UnsupportedOperationException(
          * 
          * @see com.vaadin.data.Property#getType()
          */
+        @Override
         public Class<?> getType() {
             return types.get(propertyId);
         }
          * 
          * @see com.vaadin.data.Property#getValue()
          */
+        @Override
         public Object getValue() {
             return items.get(itemId).get(propertyId);
         }
          * 
          * @see com.vaadin.data.Property#isReadOnly()
          */
+        @Override
         public boolean isReadOnly() {
             return readOnlyProperties.contains(this);
         }
          * 
          * @see com.vaadin.data.Property#setReadOnly(boolean)
          */
+        @Override
         public void setReadOnly(boolean newStatus) {
             if (newStatus) {
                 readOnlyProperties.add(this);
          * 
          * @see com.vaadin.data.Property#setValue(java.lang.Object)
          */
+        @Override
         public void setValue(Object newValue) throws Property.ReadOnlyException {
             // Gets the Property set
             final Map<Object, Object> propertySet = items.get(itemId);
          * @see com.vaadin.data.Property.ValueChangeNotifier#addListener(
          * com.vaadin.data.Property.ValueChangeListener)
          */
+        @Override
         public void addListener(Property.ValueChangeListener listener) {
             addSinglePropertyChangeListener(propertyId, itemId, listener);
         }
          * @see com.vaadin.data.Property.ValueChangeNotifier#removeListener
          * (com.vaadin.data.Property.ValueChangeListener)
          */
+        @Override
         public void removeListener(Property.ValueChangeListener listener) {
             removeSinglePropertyChangeListener(propertyId, itemId, listener);
         }
      * @see com.vaadin.data.Container.Sortable#sort(java.lang.Object[],
      * boolean[])
      */
+    @Override
     public void sort(Object[] propertyId, boolean[] ascending) {
         sortContainer(propertyId, ascending);
     }
      * @see com.vaadin.data.Container.Sortable#getSortableContainerPropertyIds
      * ()
      */
+    @Override
     public Collection<?> getSortableContainerPropertyIds() {
         return getSortablePropertyIds();
     }
         return nc;
     }
 
+    @Override
     public void addContainerFilter(Object propertyId, String filterString,
             boolean ignoreCase, boolean onlyMatchPrefix) {
         try {
         }
     }
 
+    @Override
     public void removeAllContainerFilters() {
         removeAllFilters();
     }
 
+    @Override
     public void removeContainerFilters(Object propertyId) {
         removeFilters(propertyId);
     }
 
+    @Override
     public void addContainerFilter(Filter filter)
             throws UnsupportedFilterException {
         addFilter(filter);
     }
 
+    @Override
     public void removeContainerFilter(Filter filter) {
         removeFilter(filter);
     }

src/com/vaadin/data/util/ItemSorter.java

      * 
      * @see Comparator#compare(Object, Object)
      */
+    @Override
     int compare(Object itemId1, Object itemId2);
 
 }

src/com/vaadin/data/util/MethodProperty.java

      * 
      * @return type of the Property
      */
+    @Override
     public final Class<? extends T> getType() {
         return type;
     }
      * 
      * @return the value of the Property
      */
+    @Override
     public T getValue() {
         try {
             return (T) getMethod.invoke(instance, getArgs);
      *         read-only mode.
      * @see #invokeSetMethod(Object)
      */
+    @Override
     @SuppressWarnings("unchecked")
     public void setValue(Object newValue) throws Property.ReadOnlyException {
 

src/com/vaadin/data/util/MethodPropertyDescriptor.java

         }
     };
 
+    @Override
     public String getName() {
         return name;
     }
 
+    @Override
     public Class<?> getPropertyType() {
         return propertyType;
     }
 
+    @Override
     public Property<?> createProperty(Object bean) {
         return new MethodProperty<Object>(propertyType, bean, readMethod,
                 writeMethod);

src/com/vaadin/data/util/NestedMethodProperty.java

         this.setMethod = setMethod;
     }
 
+    @Override
     public Class<? extends T> getType() {
         return type;
     }
      * 
      * @return the value of the Property
      */
+    @Override
     public T getValue() {
         try {
             Object object = instance;
      *         read-only mode.
      * @see #invokeSetMethod(Object)
      */
+    @Override
     public void setValue(Object newValue) throws ReadOnlyException {
         // Checks the mode
         if (isReadOnly()) {

src/com/vaadin/data/util/NestedPropertyDescriptor.java

         this.propertyType = property.getType();
     }
 
+    @Override
     public String getName() {
         return name;
     }
 
+    @Override
     public Class<?> getPropertyType() {
         return propertyType;
     }
 
+    @Override
     public Property<?> createProperty(BT bean) {
         return new NestedMethodProperty<Object>(bean, name);
     }

src/com/vaadin/data/util/ObjectProperty.java

      * 
      * @return type of the Property
      */
+    @Override
     public final Class<T> getType() {
         return type;
     }
      * 
      * @return the value stored in the Property
      */
+    @Override
     public T getValue() {
         return value;
     }
      * @throws <code>Property.ReadOnlyException</code> if the object is in
      *         read-only mode
      */
+    @Override
     @SuppressWarnings("unchecked")
     public void setValue(Object newValue) throws Property.ReadOnlyException {
 

src/com/vaadin/data/util/PropertyFormatter.java

      * @return the current data source as a Property, or <code>null</code> if
      *         none defined.
      */
+    @Override
     public Property<T> getPropertyDataSource() {
         return dataSource;
     }
      * @param newDataSource
      *            the new data source Property.
      */
+    @Override
     public void setPropertyDataSource(Property newDataSource) {
 
         boolean readOnly = false;
     }
 
     /* Documented in the interface */
+    @Override
     public Class<String> getType() {
         return String.class;
     }
      * @return If the datasource returns null, this is null. Otherwise this is
      *         String given by format().
      */
+    @Override
     public String getValue() {
         T value = dataSource == null ? null : dataSource.getValue();
         if (value == null) {
         }
     }
 
+    @Override
     public void setValue(Object newValue) throws ReadOnlyException {
         if (dataSource == null) {
             return;
      * 
      * This should not be called directly.
      */
+    @Override
     public void valueChange(com.vaadin.data.Property.ValueChangeEvent event) {
         fireValueChange();
     }
      * 
      * This should not be called directly.
      */
+    @Override
     public void readOnlyStatusChange(
             com.vaadin.data.Property.ReadOnlyStatusChangeEvent event) {
         fireReadOnlyStatusChange();

src/com/vaadin/data/util/PropertysetItem.java

      *            the identifier of the Property to get.
      * @return the Property with the given ID or <code>null</code>
      */
+    @Override
     public Property<?> getItemProperty(Object id) {
         return map.get(id);
     }
      * @return unmodifiable collection containing IDs of the Properties stored
      *         the Item
      */
+    @Override
     public Collection<?> getItemPropertyIds() {
         return Collections.unmodifiableCollection(list);
     }
      * @return <code>true</code> if the operation succeeded <code>false</code>
      *         if not
      */
+    @Override
     public boolean removeItemProperty(Object id) {
 
         // Cant remove missing properties
      * @return <code>true</code> if the operation succeeded, <code>false</code>
      *         if not
      */
+    @Override
     public boolean addItemProperty(Object id, Property property) {
 
         // Null ids are not accepted
          * 
          * @return source object of the event as an <code>Item</code>
          */
+        @Override
         public Item getItem() {
             return (Item) getSource();
         }
      * @param listener
      *            the new Listener to be registered.
      */
+    @Override
     public void addListener(Item.PropertySetChangeListener listener) {
         if (propertySetChangeListeners == null) {
             propertySetChangeListeners = new LinkedList<PropertySetChangeListener>();
      * @param listener
      *            the Listener to be removed.
      */
+    @Override
     public void removeListener(Item.PropertySetChangeListener listener) {
         if (propertySetChangeListeners != null) {
             propertySetChangeListeners.remove(listener);

src/com/vaadin/data/util/QueryContainer.java

      * @return Item Id.
      */
 
+    @Override
     public Item getItem(Object id) {
         return new Row(id);
     }
      * @return Collection of Property ID.
      */
 
+    @Override
     public Collection<String> getContainerPropertyIds() {
         return propertyIds;
     }
      * 
      * @return collection of Item IDs
      */
+    @Override
     public Collection<?> getItemIds() {
         final Collection<Integer> c = new ArrayList<Integer>(size);
         for (int i = 1; i <= size; i++) {
      *         otherwise.
      */
 
+    @Override
     public synchronized Property<?> getContainerProperty(Object itemId,
             Object propertyId) {
         if (!(itemId instanceof Integer && propertyId instanceof String)) {
      * @return data type of the Properties
      */
 
+    @Override
     public Class<?> getType(Object id) {
         return propertyTypes.get(id);
     }
      * 
      * @return the number of items in the container.
      */
+    @Override
     public int size() {
         return size;
     }
      * @return <code>true</code> if given id is in the container;
      *         <code>false</code> otherwise.
      */
+    @Override
     public boolean containsId(Object id) {
         if (!(id instanceof Integer)) {
             return false;
      * @throws UnsupportedOperationException
      *             if the addItem method is not supported.
      */
+    @Override
     public Item addItem(Object itemId) throws UnsupportedOperationException {
         throw new UnsupportedOperationException();
     }
      * @throws UnsupportedOperationException
      *             if the addItem method is not supported.
      */
+    @Override
     public Object addItem() throws UnsupportedOperationException {
         throw new UnsupportedOperationException();
     }
      * @throws UnsupportedOperationException
      *             if the removeItem method is not supported.
      */
+    @Override
     public boolean removeItem(Object itemId)
             throws UnsupportedOperationException {
         throw new UnsupportedOperationException();
      * @throws UnsupportedOperationException
      *             if the addContainerProperty method is not supported.
      */
+    @Override
     public boolean addContainerProperty(Object propertyId, Class<?> type,
             Object defaultValue) throws UnsupportedOperationException {
         throw new UnsupportedOperationException();
      * @throws UnsupportedOperationException
      *             if the removeContainerProperty method is not supported.
      */
+    @Override
     public boolean removeContainerProperty(Object propertyId)
             throws UnsupportedOperationException {
         throw new UnsupportedOperationException();
      * @throws UnsupportedOperationException
      *             if the removeAllItems method is not supported.
      */
+    @Override
     public boolean removeAllItems() throws UnsupportedOperationException {
         throw new UnsupportedOperationException();
     }
      * @throws UnsupportedOperationException
      *             if the addItemAfter method is not supported.
      */
+    @Override
     public Item addItemAfter(Object previousItemId, Object newItemId)
             throws UnsupportedOperationException {
         throw new UnsupportedOperationException();
      * @throws UnsupportedOperationException
      *             if the addItemAfter method is not supported.
      */
+    @Override
     public Object addItemAfter(Object previousItemId)
             throws UnsupportedOperationException {
         throw new UnsupportedOperationException();
      * 
      * @return ID of the first Item in the list.
      */
+    @Override
     public Object firstItemId() {
         if (size < 1) {
             return null;
      * @param id
      *            ID of an Item in the Container.
      */
+    @Override
     public boolean isFirstId(Object id) {
         return size > 0 && (id instanceof Integer)
                 && ((Integer) id).intValue() == 1;
      *            ID of an Item in the Container
      * 
      */
+    @Override
     public boolean isLastId(Object id) {
         return size > 0 && (id instanceof Integer)
                 && ((Integer) id).intValue() == size;
      * 
      * @return ID of the last Item.
      */
+    @Override
     public Object lastItemId() {
         if (size < 1) {
             return null;
      *            ID of an Item in the Container.
      * @return ID of the next Item or null.
      */
+    @Override
     public Object nextItemId(Object id) {
         if (size < 1 || !(id instanceof Integer)) {
             return null;
      *            ID of an Item in the Container.
      * @return ID of the previous Item or null.
      */
+    @Override
     public Object prevItemId(Object id) {
         if (size < 1 || !(id instanceof Integer)) {
             return null;
          * @throws UnsupportedOperationException
          *             if the addItemProperty method is not supported.
          */
+        @Override
         public boolean addItemProperty(Object id, Property property)
                 throws UnsupportedOperationException {
             throw new UnsupportedOperationException();
          *            identifier of the Property to get
          * @return the Property with the given ID or <code>null</code>
          */
+        @Override
         public Property<?> getItemProperty(Object propertyId) {
             return getContainerProperty(id, propertyId);
         }
          * @return unmodifiable collection containing IDs of the Properties
          *         stored the Item.
          */
+        @Override
         public Collection<String> getItemPropertyIds() {
             return propertyIds;
         }
          * @throws UnsupportedOperationException
          *             if the removeItemProperty is not supported.
          */
+        @Override
         public boolean removeItemProperty(Object id)
                 throws UnsupportedOperationException {
             throw new UnsupportedOperationException();
      * @throws UnsupportedOperationException
      *             if the addItemAt is not supported.
      */
+    @Override
     public Item addItemAt(int index, Object newItemId)
             throws UnsupportedOperationException {
         throw new UnsupportedOperationException();
      *             if the addItemAt is not supported.
      */
 
+    @Override
     public Object addItemAt(int index) throws UnsupportedOperationException {
         throw new UnsupportedOperationException();
     }
      *            Index Id.
      * @return ID in the given index.
      */
+    @Override
     public Object getIdByIndex(int index) {
         if (size < 1 || index < 0 || index >= size) {
             return null;
      *         Item
      */
 
+    @Override
     public int indexOfId(Object id) {
         if (size < 1 || !(id instanceof Integer)) {
             return -1;

src/com/vaadin/data/util/TextFileProperty.java

      * 
      * @see com.vaadin.data.Property#getType()
      */
+    @Override
     public Class<String> getType() {
         return String.class;
     }
      * 
      * @see com.vaadin.data.Property#getValue()
      */
+    @Override
     public String getValue() {
         if (file == null) {
             return null;
      * 
      * @see com.vaadin.data.Property#setValue(java.lang.Object)
      */
+    @Override
     public void setValue(Object newValue) throws ReadOnlyException {
         if (isReadOnly()) {
             throw new ReadOnlyException();

src/com/vaadin/data/util/TransactionalPropertyWrapper.java

             ((ValueChangeNotifier) wrappedProperty)
                     .addListener(new ValueChangeListener() {
 
+                        @Override
                         public void valueChange(ValueChangeEvent event) {
                             fireValueChange();
                         }
         }
     }
 
+    @Override
     public Class getType() {
         return wrappedProperty.getType();
     }
 
+    @Override
     public T getValue() {
         return wrappedProperty.getValue();
     }
 
+    @Override
     public void setValue(Object newValue) throws ReadOnlyException {
         // Causes a value change to be sent to this listener which in turn fires
         // a new value change event for this property
         wrappedProperty.setValue(newValue);
     }
 
+    @Override
     public void startTransaction() {
         inTransaction = true;
         valueBeforeTransaction = getValue();
     }
 
+    @Override
     public void commit() {
         endTransaction();
     }
 
+    @Override
     public void rollback() {
         try {
             wrappedProperty.setValue(valueBeforeTransaction);

src/com/vaadin/data/util/converter/DateToLongConverter.java

      * com.vaadin.data.util.converter.Converter#convertToModel(java.lang.Object,
      * java.util.Locale)
      */
+    @Override
     public Long convertToModel(Date value, Locale locale) {
         if (value == null) {
             return null;
      * com.vaadin.data.util.converter.Converter#convertToPresentation(java.lang
      * .Object, java.util.Locale)
      */
+    @Override
     public Date convertToPresentation(Long value, Locale locale) {
         if (value == null) {
             return null;
      * 
      * @see com.vaadin.data.util.converter.Converter#getModelType()
      */
+    @Override
     public Class<Long> getModelType() {
         return Long.class;
     }
      * 
      * @see com.vaadin.data.util.converter.Converter#getPresentationType()
      */
+    @Override
     public Class<Date> getPresentationType() {
         return Date.class;
     }

src/com/vaadin/data/util/converter/DefaultConverterFactory.java

     private final static Logger log = Logger
             .getLogger(DefaultConverterFactory.class.getName());
 
+    @Override
     public <PRESENTATION, MODEL> Converter<PRESENTATION, MODEL> createConverter(
             Class<PRESENTATION> presentationType, Class<MODEL> modelType) {
         Converter<PRESENTATION, MODEL> converter = findConverter(

src/com/vaadin/data/util/converter/ReverseConverter.java

      * @see com.vaadin.data.util.converter.Converter#convertToModel(java
      * .lang.Object, java.util.Locale)
      */
+    @Override
     public MODEL convertToModel(PRESENTATION value, Locale locale)
             throws com.vaadin.data.util.converter.Converter.ConversionException {
         return realConverter.convertToPresentation(value, locale);
      * com.vaadin.data.util.converter.Converter#convertToPresentation(java.lang
      * .Object, java.util.Locale)
      */
+    @Override
     public PRESENTATION convertToPresentation(MODEL value, Locale locale)
             throws com.vaadin.data.util.converter.Converter.ConversionException {
         return realConverter.convertToModel(value, locale);
      * 
      * @see com.vaadin.data.util.converter.Converter#getSourceType()
      */
+    @Override
     public Class<MODEL> getModelType() {
         return realConverter.getPresentationType();
     }
      * 
      * @see com.vaadin.data.util.converter.Converter#getTargetType()
      */
+    @Override
     public Class<PRESENTATION> getPresentationType() {
         return realConverter.getModelType();
     }

src/com/vaadin/data/util/converter/StringToBooleanConverter.java

      * com.vaadin.data.util.converter.Converter#convertToModel(java.lang.Object,
      * java.util.Locale)
      */
+    @Override
     public Boolean convertToModel(String value, Locale locale)
             throws ConversionException {
         if (value == null) {
      * com.vaadin.data.util.converter.Converter#convertToPresentation(java.lang
      * .Object, java.util.Locale)
      */
+    @Override
     public String convertToPresentation(Boolean value, Locale locale)
             throws ConversionException {
         if (value == null) {
      * 
      * @see com.vaadin.data.util.converter.Converter#getModelType()
      */
+    @Override
     public Class<Boolean> getModelType() {
         return Boolean.class;
     }
      * 
      * @see com.vaadin.data.util.converter.Converter#getPresentationType()
      */
+    @Override
     public Class<String> getPresentationType() {
         return String.class;
     }

src/com/vaadin/data/util/converter/StringToDateConverter.java

      * com.vaadin.data.util.converter.Converter#convertToModel(java.lang.Object,
      * java.util.Locale)
      */
+    @Override
     public Date convertToModel(String value, Locale locale)
             throws com.vaadin.data.util.converter.Converter.ConversionException {
         if (value == null) {
      * com.vaadin.data.util.converter.Converter#convertToPresentation(java.lang
      * .Object, java.util.Locale)
      */
+    @Override
     public String convertToPresentation(Date value, Locale locale)
             throws com.vaadin.data.util.converter.Converter.ConversionException {
         if (value == null) {
      * 
      * @see com.vaadin.data.util.converter.Converter#getModelType()
      */
+    @Override
     public Class<Date> getModelType() {
         return Date.class;
     }
      * 
      * @see com.vaadin.data.util.converter.Converter#getPresentationType()
      */
+    @Override
     public Class<String> getPresentationType() {
         return String.class;
     }

src/com/vaadin/data/util/converter/StringToDoubleConverter.java

      * com.vaadin.data.util.converter.Converter#convertToModel(java.lang.Object,
      * java.util.Locale)
      */
+    @Override
     public Double convertToModel(String value, Locale locale)
             throws ConversionException {
         if (value == null) {
      * com.vaadin.data.util.converter.Converter#convertToPresentation(java.lang
      * .Object, java.util.Locale)
      */
+    @Override
     public String convertToPresentation(Double value, Locale locale)
             throws ConversionException {
         if (value == null) {
      * 
      * @see com.vaadin.data.util.converter.Converter#getModelType()
      */
+    @Override
     public Class<Double> getModelType() {
         return Double.class;
     }
      * 
      * @see com.vaadin.data.util.converter.Converter#getPresentationType()
      */
+    @Override
     public Class<String> getPresentationType() {
         return String.class;
     }

src/com/vaadin/data/util/converter/StringToIntegerConverter.java

         return NumberFormat.getIntegerInstance(locale);
     }
 
+    @Override
     public Integer convertToModel(String value, Locale locale)
             throws ConversionException {
         if (value == null) {
         return parsedValue.intValue();
     }
 
+    @Override
     public String convertToPresentation(Integer value, Locale locale)
             throws ConversionException {
         if (value == null) {
         return getFormat(locale).format(value);
     }
 
+    @Override
     public Class<Integer> getModelType() {
         return Integer.class;
     }
 
+    @Override
     public Class<String> getPresentationType() {
         return String.class;
     }

src/com/vaadin/data/util/converter/StringToNumberConverter.java

      * com.vaadin.data.util.converter.Converter#convertToModel(java.lang.Object,
      * java.util.Locale)
      */
+    @Override
     public Number convertToModel(String value, Locale locale)
             throws ConversionException {
         if (value == null) {
      * com.vaadin.data.util.converter.Converter#convertToPresentation(java.lang
      * .Object, java.util.Locale)
      */
+    @Override
     public String convertToPresentation(Number value, Locale locale)
             throws ConversionException {
         if (value == null) {
      * 
      * @see com.vaadin.data.util.converter.Converter#getModelType()
      */
+    @Override
     public Class<Number> getModelType() {
         return Number.class;
     }
      * 
      * @see com.vaadin.data.util.converter.Converter#getPresentationType()
      */
+    @Override
     public Class<String> getPresentationType() {
         return String.class;
     }

src/com/vaadin/data/util/filter/AbstractJunctionFilter.java

      * If there are no sub-filters, false is returned - override in subclasses
      * to change this behavior.
      */
+    @Override
     public boolean appliesToProperty(Object propertyId) {
         for (Filter filter : getFilters()) {
             if (filter.appliesToProperty(propertyId)) {

src/com/vaadin/data/util/filter/And.java

         super(filters);
     }
 
+    @Override
     public boolean passesFilter(Object itemId, Item item)
             throws UnsupportedFilterException {
         for (Filter filter : getFilters()) {

src/com/vaadin/data/util/filter/Between.java

         return endValue;
     }
 
+    @Override
     public boolean passesFilter(Object itemId, Item item)
             throws UnsupportedOperationException {
         Object value = item.getItemProperty(getPropertyId()).getValue();
         return false;
     }
 
+    @Override
     public boolean appliesToProperty(Object propertyId) {
         return getPropertyId() != null && getPropertyId().equals(propertyId);
     }

src/com/vaadin/data/util/filter/Compare.java

         this.operation = operation;
     }
 
+    @Override
     public boolean passesFilter(Object itemId, Item item) {
         final Property<?> p = item.getItemProperty(getPropertyId());
         if (null == p) {
                 + value1 + ", " + getValue());
     }
 
+    @Override
     public boolean appliesToProperty(Object propertyId) {
         return getPropertyId().equals(propertyId);
     }

src/com/vaadin/data/util/filter/IsNull.java

         this.propertyId = propertyId;
     }
 
+    @Override
     public boolean passesFilter(Object itemId, Item item)
             throws UnsupportedOperationException {
         final Property<?> p = item.getItemProperty(getPropertyId());
         return null == p.getValue();
     }
 
+    @Override
     public boolean appliesToProperty(Object propertyId) {
         return getPropertyId().equals(propertyId);
     }

src/com/vaadin/data/util/filter/Like.java

         return caseSensitive;
     }
 
+    @Override
     public boolean passesFilter(Object itemId, Item item)
             throws UnsupportedOperationException {
         if (!item.getItemProperty(getPropertyId()).getType()
         return colValue.toUpperCase().matches(pattern.toUpperCase());
     }
 
+    @Override
     public boolean appliesToProperty(Object propertyId) {
         return getPropertyId() != null && getPropertyId().equals(propertyId);
     }

src/com/vaadin/data/util/filter/Not.java

         return filter;
     }
 
+    @Override
     public boolean passesFilter(Object itemId, Item item)
             throws UnsupportedOperationException {
         return !filter.passesFilter(itemId, item);
      * 
      * @return boolean
      */
+    @Override
     public boolean appliesToProperty(Object propertyId) {
         return filter.appliesToProperty(propertyId);
     }

src/com/vaadin/data/util/filter/Or.java

         super(filters);
     }
 
+    @Override
     public boolean passesFilter(Object itemId, Item item)
             throws UnsupportedFilterException {
         for (Filter filter : getFilters()) {

src/com/vaadin/data/util/filter/SimpleStringFilter.java

         this.onlyMatchPrefix = onlyMatchPrefix;
     }
 
+    @Override
     public boolean passesFilter(Object itemId, Item item) {
         final Property<?> p = item.getItemProperty(propertyId);
         if (p == null) {
         return true;
     }
 
+    @Override
     public boolean appliesToProperty(Object propertyId) {
         return this.propertyId.equals(propertyId);
     }

src/com/vaadin/data/util/sqlcontainer/ColumnProperty.java

         this.readOnly = readOnly;
     }
 
+    @Override
     public Object getValue() {
         if (isModified()) {
             return changedValue;
         return value;
     }
 
+    @Override
     public void setValue(Object newValue) throws ReadOnlyException {
         if (newValue == null && !nullable) {
             throw new NotNullableException(
                 || newValue.equals(referenceValue);
     }
 
+    @Override
     public Class<?> getType() {
         return type;
     }
 
+    @Override
     public boolean isReadOnly() {
         return readOnly;
     }
         return allowReadOnlyChange;
     }
 
+    @Override
     public void setReadOnly(boolean newStatus) {
         if (allowReadOnlyChange) {
             readOnly = newStatus;

src/com/vaadin/data/util/sqlcontainer/RowItem.java

         this.id = id;
     }
 
+    @Override
     public Property<?> getItemProperty(Object id) {
         if (id instanceof String && id != null) {
             for (ColumnProperty cp : properties) {
         return null;
     }
 
+    @Override
     public Collection<?> getItemPropertyIds() {
         Collection<String> ids = new ArrayList<String>(properties.size());
         for (ColumnProperty cp : properties) {
      * Adding properties is not supported. Properties are generated by
      * SQLContainer.
      */
+    @Override
     public boolean addItemProperty(Object id, Property property)
             throws UnsupportedOperationException {
         throw new UnsupportedOperationException();
      * Removing properties is not supported. Properties are generated by
      * SQLContainer.
      */
+    @Override
     public boolean removeItemProperty(Object id)
             throws UnsupportedOperationException {
         throw new UnsupportedOperationException();

src/com/vaadin/data/util/sqlcontainer/SQLContainer.java

      * {@inheritDoc}
      */
 
+    @Override
     public Object addItem() throws UnsupportedOperationException {
         Object emptyKey[] = new Object[delegate.getPrimaryKeyColumns().size()];
         RowId itemId = new TemporaryRowId(emptyKey);
      * @see com.vaadin.data.Container#containsId(java.lang.Object)
      */
 
+    @Override
     public boolean containsId(Object itemId) {
         if (itemId == null) {
             return false;
      * java.lang.Object)
      */
 
+    @Override
     public Property<?> getContainerProperty(Object itemId, Object propertyId) {
         Item item = getItem(itemId);
         if (item == null) {
      * @see com.vaadin.data.Container#getContainerPropertyIds()
      */
 
+    @Override
     public Collection<?> getContainerPropertyIds() {
         return Collections.unmodifiableCollection(propertyIds);
     }
      * @see com.vaadin.data.Container#getItem(java.lang.Object)
      */
 
+    @Override
     public Item getItem(Object itemId) {
         if (!cachedItems.containsKey(itemId)) {
             int index = indexOfId(itemId);
      * {@inheritDoc}
      */
 
+    @Override
     public Collection<?> getItemIds() {
         updateCount();
         ArrayList<RowId> ids = new ArrayList<RowId>();
      * @see com.vaadin.data.Container#getType(java.lang.Object)
      */
 
+    @Override
     public Class<?> getType(Object propertyId) {
         if (!propertyIds.contains(propertyId)) {
             return null;
      * @see com.vaadin.data.Container#size()
      */
 
+    @Override
     public int size() {
         updateCount();
         return size + sizeOfAddedItems() - removedItems.size();
      * @see com.vaadin.data.Container#removeItem(java.lang.Object)
      */
 
+    @Override
     public boolean removeItem(Object itemId)
             throws UnsupportedOperationException {
         if (!containsId(itemId)) {
      * @see com.vaadin.data.Container#removeAllItems()
      */
 
+    @Override
     public boolean removeAllItems() throws UnsupportedOperationException {
         if (autoCommit) {
             /* Remove and commit instantly. */
      * {@inheritDoc}
      */
 
+    @Override
     public void addContainerFilter(Filter filter)
             throws UnsupportedFilterException {
         // filter.setCaseSensitive(!ignoreCase);
      * {@inheritDoc}
      */
 
+    @Override
     public void removeContainerFilter(Filter filter) {
         filters.remove(filter);
     }
      * {@inheritDoc}
      */
 
+    @Override
     public void removeAllContainerFilters() {
         filters.clear();
         refresh();
      * @see com.vaadin.data.Container.Indexed#indexOfId(java.lang.Object)
      */
 
+    @Override
     public int indexOfId(Object itemId) {
         // First check if the id is in the added items
         for (int ix = 0; ix < addedItems.size(); ix++) {
      * @see com.vaadin.data.Container.Indexed#getIdByIndex(int)
      */
 
+    @Override
     public Object getIdByIndex(int index) {
         if (index < 0 || index > size() - 1) {
             return null;
      * @see com.vaadin.data.Container.Ordered#nextItemId(java.lang.Object)
      */
 
+    @Override
     public Object nextItemId(Object itemId) {
         return getIdByIndex(indexOfId(itemId) + 1);
     }
      * @see com.vaadin.data.Container.Ordered#prevItemId(java.lang.Object)
      */
 
+    @Override
     public Object prevItemId(Object itemId) {
         return getIdByIndex(indexOfId(itemId) - 1);
     }
      * @see com.vaadin.data.Container.Ordered#firstItemId()
      */
 
+    @Override
     public Object firstItemId() {
         updateCount();
         if (size == 0) {
      * @see com.vaadin.data.Container.Ordered#lastItemId()
      */
 
+    @Override
     public Object lastItemId() {
         if (addedItems.isEmpty()) {
             int lastIx = size() - 1;
      * @see com.vaadin.data.Container.Ordered#isFirstId(java.lang.Object)
      */
 
+    @Override
     public boolean isFirstId(Object itemId) {
         return firstItemId().equals(itemId);
     }
      * @see com.vaadin.data.Container.Ordered#isLastId(java.lang.Object)
      */
 
+    @Override
     public boolean isLastId(Object itemId) {
         return lastItemId().equals(itemId);
     }
      * boolean[])
      */
 
+    @Override
     public void sort(Object[] propertyId, boolean[] ascending) {
         sorters.clear();
         if (propertyId == null || propertyId.length == 0) {
      * @see com.vaadin.data.Container.Sortable#getSortableContainerPropertyIds()
      */
 
+    @Override
     public Collection<?> getSortableContainerPropertyIds() {
         return getContainerPropertyIds();
     }
      * java.lang.Class, java.lang.Object)
      */
 
+    @Override
     public boolean addContainerProperty(Object propertyId, Class<?> type,
             Object defaultValue) throws UnsupportedOperationException {
         throw new UnsupportedOperationException();
      * @see com.vaadin.data.Container#removeContainerProperty(java.lang.Object)
      */
 
+    @Override
     public boolean removeContainerProperty(Object propertyId)
             throws UnsupportedOperationException {
         throw new UnsupportedOperationException();
      * @see com.vaadin.data.Container#addItem(java.lang.Object)
      */
 
+    @Override
     public Item addItem(Object itemId) throws UnsupportedOperationException {
         throw new UnsupportedOperationException();
     }
      * java.lang.Object)
      */
 
+    @Override
     public Item addItemAfter(Object previousItemId, Object newItemId)
             throws UnsupportedOperationException {
         throw new UnsupportedOperationException();
      * @see com.vaadin.data.Container.Indexed#addItemAt(int, java.lang.Object)
      */
 
+    @Override
     public Item addItemAt(int index, Object newItemId)
             throws UnsupportedOperationException {
         throw new UnsupportedOperationException();
      * @see com.vaadin.data.Container.Indexed#addItemAt(int)
      */
 
+    @Override
     public Object addItemAt(int index) throws UnsupportedOperationException {
         throw new UnsupportedOperationException();
     }
      * @see com.vaadin.data.Container.Ordered#addItemAfter(java.lang.Object)
      */
 
+    @Override
     public Object addItemAfter(Object previousItemId)
             throws UnsupportedOperationException {
         throw new UnsupportedOperationException();
      * .data.Container.ItemSetChangeListener)
      */
 
+    @Override
     public void addListener(Container.ItemSetChangeListener listener) {
         if (itemSetChangeListeners == null) {
             itemSetChangeListeners = new LinkedList<Container.ItemSetChangeListener>();
      * .data.Container.ItemSetChangeListener)
      */
 
+    @Override
     public void removeListener(Container.ItemSetChangeListener listener) {
         if (itemSetChangeListeners != null) {
             itemSetChangeListeners.remove(listener);
             super(source);
         }
 
+        @Override
         public Container getContainer() {
             return (Container) getSource();
         }

src/com/vaadin/data/util/sqlcontainer/connection/J2EEConnectionPool.java

         this.dataSourceJndiName = dataSourceJndiName;
     }
 
+    @Override
     public Connection reserveConnection() throws SQLException {
         Connection conn = getDataSource().getConnection();
         conn.setAutoCommit(false);
         }
     }
 
+    @Override
     public void releaseConnection(Connection conn) {
         if (conn != null) {
             try {
         }
     }
 
+    @Override
     public void destroy() {
         dataSource = null;
     }

src/com/vaadin/data/util/sqlcontainer/connection/SimpleJDBCConnectionPool.java

         initialized = true;
     }
 
+    @Override
     public synchronized Connection reserveConnection() throws SQLException {
         if (!initialized) {
             initializeConnections();
         return c;
     }
 
+    @Override
     public synchronized void releaseConnection(Connection conn) {
         if (conn == null || !initialized) {
             return;
         return c;
     }
 
+    @Override
     public void destroy() {
         for (Connection c : availableConnections) {
             try {

src/com/vaadin/data/util/sqlcontainer/query/FreeformQuery.java

      * 
      * {@inheritDoc}
      */
+    @Override
     public int getCount() throws SQLException {
         // First try the delegate
         int count = countByDelegate();
      * 
      * @see FreeformQueryDelegate#getQueryString(int, int)
      */
+    @Override
     @SuppressWarnings("deprecation")
     public ResultSet getResults(int offset, int pagelength) throws SQLException {
         if (activeConnection == null) {
         return rs;
     }
 
+    @Override
     @SuppressWarnings("deprecation")
     public boolean implementationRespectsPagingLimits() {
         if (delegate == null) {
      * com.vaadin.data.util.sqlcontainer.query.QueryDelegate#setFilters(java
      * .util.List)
      */
+    @Override
     public void setFilters(List<Filter> filters)
             throws UnsupportedOperationException {
         if (delegate != null) {
      * com.vaadin.data.util.sqlcontainer.query.QueryDelegate#setOrderBy(java
      * .util.List)
      */
+    @Override
     public void setOrderBy(List<OrderBy> orderBys)
             throws UnsupportedOperationException {
         if (delegate != null) {
      * com.vaadin.data.util.sqlcontainer.query.QueryDelegate#storeRow(com.vaadin
      * .data.util.sqlcontainer.RowItem)
      */
+    @Override
     public int storeRow(RowItem row) throws SQLException {
         if (activeConnection == null) {
             throw new IllegalStateException("No transaction is active!");
      * com.vaadin.data.util.sqlcontainer.query.QueryDelegate#removeRow(com.vaadin
      * .data.util.sqlcontainer.RowItem)
      */
+    @Override
     public boolean removeRow(RowItem row) throws SQLException {
         if (activeConnection == null) {
             throw new IllegalStateException("No transaction is active!");
      * @see
      * com.vaadin.data.util.sqlcontainer.query.QueryDelegate#beginTransaction()
      */
+    @Override
     public synchronized void beginTransaction()
             throws UnsupportedOperationException, SQLException {
         if (activeConnection != null) {
      * 
      * @see com.vaadin.data.util.sqlcontainer.query.QueryDelegate#commit()
      */
+    @Override
     public synchronized void commit() throws UnsupportedOperationException,
             SQLException {
         if (activeConnection == null) {
      * 
      * @see com.vaadin.data.util.sqlcontainer.query.QueryDelegate#rollback()
      */
+    @Override
     public synchronized void rollback() throws UnsupportedOperationException,
             SQLException {
         if (activeConnection == null) {
      * com.vaadin.data.util.sqlcontainer.query.QueryDelegate#getPrimaryKeyColumns
      * ()
      */
+    @Override
     public List<String> getPrimaryKeyColumns() {
         return primaryKeyColumns;
     }
      * @see FreeformQueryDelegate#getContainsRowQueryString(Object...)
      * 
      */
+    @Override
     @SuppressWarnings("deprecation")
     public boolean containsRowWithKey(Object... keys) throws SQLException {
         String query = null;

src/com/vaadin/data/util/sqlcontainer/query/TableQuery.java

      * 
      * @see com.vaadin.addon.sqlcontainer.query.QueryDelegate#getCount()
      */
+    @Override
     public int getCount() throws SQLException {
         getLogger().log(Level.FINE, "Fetching count...");
         StatementHelper sh = sqlGenerator.generateSelectQuery(tableName,
      * @see com.vaadin.addon.sqlcontainer.query.QueryDelegate#getResults(int,
      * int)
      */
+    @Override
     public ResultSet getResults(int offset, int pagelength) throws SQLException {
         StatementHelper sh;
         /*
      * @see com.vaadin.addon.sqlcontainer.query.QueryDelegate#
      * implementationRespectsPagingLimits()
      */
+    @Override
     public boolean implementationRespectsPagingLimits() {
         return true;
     }
      * com.vaadin.addon.sqlcontainer.query.QueryDelegate#storeRow(com.vaadin
      * .addon.sqlcontainer.RowItem)
      */
+    @Override
     public int storeRow(RowItem row) throws UnsupportedOperationException,
             SQLException {
         if (row == null) {
      * com.vaadin.addon.sqlcontainer.query.QueryDelegate#setFilters(java.util
      * .List)
      */
+    @Override
     public void setFilters(List<Filter> filters)
             throws UnsupportedOperationException {
         if (filters == null) {
      * com.vaadin.addon.sqlcontainer.query.QueryDelegate#setOrderBy(java.util
      * .List)
      */
+    @Override
     public void setOrderBy(List<OrderBy> orderBys)
             throws UnsupportedOperationException {
         if (orderBys == null) {
      * 
      * @see com.vaadin.addon.sqlcontainer.query.QueryDelegate#beginTransaction()
      */
+    @Override
     public void beginTransaction() throws UnsupportedOperationException,
             SQLException {
         if (transactionOpen && activeConnection != null) {
      * 
      * @see com.vaadin.addon.sqlcontainer.query.QueryDelegate#commit()
      */
+    @Override
     public void commit() throws UnsupportedOperationException, SQLException {
         if (transactionOpen && activeConnection != null) {
             getLogger().log(Level.FINE, "DB -> commit");
      * 
      * @see com.vaadin.addon.sqlcontainer.query.QueryDelegate#rollback()
      */
+    @Override
     public void rollback() throws UnsupportedOperationException, SQLException {
         if (transactionOpen && activeConnection != null) {
             getLogger().log(Level.FINE, "DB -> rollback");
      * @see
      * com.vaadin.addon.sqlcontainer.query.QueryDelegate#getPrimaryKeyColumns()
      */
+    @Override
     public List<String> getPrimaryKeyColumns() {
         return Collections.unmodifiableList(primaryKeyColumns);
     }
      * com.vaadin.addon.sqlcontainer.query.QueryDelegate#removeRow(com.vaadin
      * .addon.sqlcontainer.RowItem)
      */
+    @Override
     public boolean removeRow(RowItem row) throws UnsupportedOperationException,
             SQLException {
         getLogger().log(Level.FINE,
      * com.vaadin.addon.sqlcontainer.query.QueryDelegate#containsRowWithKey(
      * java.lang.Object[])
      */
+    @Override
     public boolean containsRowWithKey(Object... keys) throws SQLException {
         ArrayList<Filter> filtersAndKeys = new ArrayList<Filter>();
         if (filters != null) {
             this.newId = newId;
         }
 
+        @Override
         public RowId getNewRowId() {
             return newId;
         }
 
+        @Override
         public RowId getOldRowId() {
             return oldId;
         }
     /**
      * Adds RowIdChangeListener to this query
      */
+    @Override
     public void addListener(RowIdChangeListener listener) {
         if (rowIdChangeListeners == null) {
             rowIdChangeListeners = new LinkedList<QueryDelegate.RowIdChangeListener>();
     /**
      * Removes the given RowIdChangeListener from this query
      */
+    @Override
     public void removeListener(RowIdChangeListener listener) {
         if (rowIdChangeListeners != null) {
             rowIdChangeListeners.remove(listener);

src/com/vaadin/data/util/sqlcontainer/query/generator/DefaultSQLGenerator.java

      * generateSelectQuery(java.lang.String, java.util.List, java.util.List,
      * int, int, java.lang.String)
      */
+    @Override
     public StatementHelper generateSelectQuery(String tableName,
             List<Filter> filters, List<OrderBy> orderBys, int offset,
             int pagelength, String toSelect) {
      * generateUpdateQuery(java.lang.String,
      * com.vaadin.addon.sqlcontainer.RowItem)
      */
+    @Override
     public StatementHelper generateUpdateQuery(String tableName, RowItem item) {
         if (tableName == null || tableName.trim().equals("")) {
             throw new IllegalArgumentException("Table name must be given.");
      * generateInsertQuery(java.lang.String,
      * com.vaadin.addon.sqlcontainer.RowItem)
      */
+    @Override
     public StatementHelper generateInsertQuery(String tableName, RowItem item) {
         if (tableName == null || tableName.trim().equals("")) {
             throw new IllegalArgumentException("Table name must be given.");
      * generateDeleteQuery(java.lang.String,
      * com.vaadin.addon.sqlcontainer.RowItem)
      */
+    @Override
     public StatementHelper generateDeleteQuery(String tableName,
             List<String> primaryKeyColumns, String versionColumn, RowItem item) {
         if (tableName == null || tableName.trim().equals("")) {

src/com/vaadin/data/util/sqlcontainer/query/generator/filter/AndTranslator.java

 
 public class AndTranslator implements FilterTranslator {
 
+    @Override
     public boolean translatesFilter(Filter filter) {
         return filter instanceof And;
     }
 
+    @Override
     public String getWhereStringForFilter(Filter filter, StatementHelper sh) {
         return QueryBuilder.group(QueryBuilder.getJoinedFilterString(
                 ((And) filter).getFilters(), "AND", sh));

src/com/vaadin/data/util/sqlcontainer/query/generator/filter/BetweenTranslator.java

 
 public class BetweenTranslator implements FilterTranslator {
 
+    @Override
     public boolean translatesFilter(Filter filter) {
         return filter instanceof Between;
     }
 
+    @Override
     public String getWhereStringForFilter(Filter filter, StatementHelper sh) {
         Between between = (Between) filter;
         sh.addParameterValue(between.getStartValue());

src/com/vaadin/data/util/sqlcontainer/query/generator/filter/CompareTranslator.java

 
 public class CompareTranslator implements FilterTranslator {
 
+    @Override
     public boolean translatesFilter(Filter filter) {
         return filter instanceof Compare;
     }
 
+    @Override
     public String getWhereStringForFilter(Filter filter, StatementHelper sh) {
         Compare compare = (Compare) filter;
         sh.addParameterValue(compare.getValue());

src/com/vaadin/data/util/sqlcontainer/query/generator/filter/IsNullTranslator.java

 
 public class IsNullTranslator implements FilterTranslator {
 
+    @Override
     public boolean translatesFilter(Filter filter) {
         return filter instanceof IsNull;
     }
 
+    @Override
     public String getWhereStringForFilter(Filter filter, StatementHelper sh) {
         IsNull in = (IsNull) filter;
         return QueryBuilder.quote(in.getPropertyId()) + " IS NULL";

src/com/vaadin/data/util/sqlcontainer/query/generator/filter/LikeTranslator.java

 
 public class LikeTranslator implements FilterTranslator {
 
+    @Override
     public boolean translatesFilter(Filter filter) {
         return filter instanceof Like;
     }
 
+    @Override
     public String getWhereStringForFilter(Filter filter, StatementHelper sh) {
         Like like = (Like) filter;
         if (like.isCaseSensitive()) {

src/com/vaadin/data/util/sqlcontainer/query/generator/filter/NotTranslator.java

 
 public class NotTranslator implements FilterTranslator {
 
+    @Override
     public boolean translatesFilter(Filter filter) {
         return filter instanceof Not;
     }
 
+    @Override
     public String getWhereStringForFilter(Filter filter, StatementHelper sh) {
         Not not = (Not) filter;
         if (not.getFilter() instanceof IsNull) {

src/com/vaadin/data/util/sqlcontainer/query/generator/filter/OrTranslator.java

 
 public class OrTranslator implements FilterTranslator {
 
+    @Override
     public boolean translatesFilter(Filter filter) {
         return filter instanceof Or;
     }
 
+    @Override
     public String getWhereStringForFilter(Filter filter, StatementHelper sh) {
         return QueryBuilder.group(QueryBuilder.getJoinedFilterString(
                 ((Or) filter).getFilters(), "OR", sh));

src/com/vaadin/data/util/sqlcontainer/query/generator/filter/SimpleStringTranslator.java

 
 public class SimpleStringTranslator implements FilterTranslator {
 
+    @Override
     public boolean translatesFilter(Filter filter) {
         return filter instanceof SimpleStringFilter;
     }
 
+    @Override
     public String getWhereStringForFilter(Filter filter, StatementHelper sh) {
         SimpleStringFilter ssf = (SimpleStringFilter) filter;
         // Create a Like filter based on the SimpleStringFilter and execute the

src/com/vaadin/data/validator/AbstractValidator.java

      */
     protected abstract boolean isValidValue(T value);
 
+    @Override
     public void validate(Object value) throws InvalidValueException {
         // isValidType ensures that value can safely be cast to TYPE
         if (!isValidType(value) || !isValidValue((T) value)) {

src/com/vaadin/data/validator/BeanValidator.java

             this.descriptor = descriptor;
         }
 
+        @Override
         public ConstraintDescriptor<?> getConstraintDescriptor() {
             return descriptor;
         }
 
+        @Override
         public Object getValidatedValue() {
             return value;
         }
      * 
      * @see com.vaadin.data.Validator#validate(java.lang.Object)
      */
+    @Override
     public void validate(final Object value) throws InvalidValueException {
         Set<?> violations = getJavaxBeanValidator().validateValue(beanClass,
                 propertyName, value);

src/com/vaadin/data/validator/CompositeValidator.java

      * @throws Validator.InvalidValueException
      *             if the value is not valid.
      */
+    @Override
     public void validate(Object value) throws Validator.InvalidValueException {
         switch (mode) {
         case AND:

src/com/vaadin/data/validator/NullValidator.java

      * @throws Validator.InvalidValueException
      *             if the value was invalid.
      */
+    @Override
     public void validate(Object value) throws Validator.InvalidValueException {
         if ((onlyNullAllowed && value != null)
                 || (!onlyNullAllowed && value == null)) {

src/com/vaadin/event/ActionManager.java

         requestRepaint(); // this goes to the new viewer
     }
 
+    @Override
     public <T extends Action & Action.Listener> void addAction(T action) {
         if (ownActions == null) {
             ownActions = new HashSet<Action>();
         }
     }
 
+    @Override
     public <T extends Action & Action.Listener> void removeAction(T action) {
         if (ownActions != null) {
             if (ownActions.remove(action)) {
         }
     }
 
+    @Override
     public void addActionHandler(Handler actionHandler) {
         if (actionHandler == this) {
             // don't add the actionHandler to itself
         }
     }
 
+    @Override
     public void removeActionHandler(Action.Handler actionHandler) {
         if (actionHandlers != null && actionHandlers.contains(actionHandler)) {
 
         }
     }
 
+    @Override
     public Action[] getActions(Object target, Object sender) {
         HashSet<Action> actions = new HashSet<Action>();
         if (ownActions != null) {
         return actions.toArray(new Action[actions.size()]);
     }
 
+    @Override
     public void handleAction(Action action, Object sender, Object target) {
         if (actionHandlers != null) {
             Handler[] array = actionHandlers.toArray(new Handler[actionHandlers

src/com/vaadin/event/EventRouter.java

      * events generated by this component. Don't add a JavaDoc comment here, we
      * use the default documentation from implemented interface.
      */
+    @Override
     public void addListener(Class<?> eventType, Object object, Method method) {
         if (listenerList == null) {
             listenerList = new LinkedHashSet<ListenerMethod>();
      * listen events generated by this component. Don't add a JavaDoc comment
      * here, we use the default documentation from implemented interface.
      */
+    @Override
     public void addListener(Class<?> eventType, Object object, String methodName) {
         if (listenerList == null) {
             listenerList = new LinkedHashSet<ListenerMethod>();
      * a JavaDoc comment here, we use the default documentation from implemented
      * interface.
      */
+    @Override
     public void removeListener(Class<?> eventType, Object target) {
         if (listenerList != null) {
             final Iterator<ListenerMethod> i = listenerList.iterator();
      * Don't add a JavaDoc comment here, we use the default documentation from
      * implemented interface.
      */
+    @Override
     public void removeListener(Class<?> eventType, Object target, Method method) {
         if (listenerList != null) {
             final Iterator<ListenerMethod> i = listenerList.iterator();
      * Don't add a JavaDoc comment here, we use the default documentation from
      * implemented interface.
      */
+    @Override
     public void removeListener(Class<?> eventType, Object target,
             String methodName) {
 

src/com/vaadin/event/FieldEvents.java

 
         protected abstract void fireEvent(Event event);
 
+        @Override
         public void blur() {
             fireEvent(new BlurEvent(component));
         }
 
+        @Override
         public void focus() {
             fireEvent(new FocusEvent(component));
         }

src/com/vaadin/event/ShortcutListener.java

         super(shorthandCaption);
     }
 
+    @Override
     abstract public void handleAction(Object sender, Object target);
 }

src/com/vaadin/event/TransferableImpl.java

         this.rawVariables = rawVariables;
     }
 
+    @Override
     public Component getSourceComponent() {
         return sourceComponent;
     }
 
+    @Override
     public Object getData(String dataFlavor) {
         return rawVariables.get(dataFlavor);
     }
 
+    @Override
     public void setData(String dataFlavor, Object value) {
         rawVariables.put(dataFlavor, value);
     }
 
+    @Override
     public Collection<String> getDataFlavors() {
         return rawVariables.keySet();
     }

src/com/vaadin/event/dd/TargetDetailsImpl.java

         this.dropTarget = dropTarget;
     }
 
+    @Override
     public Object getData(String key) {
         return data.get(key);
     }
         return data.put(key, value);
     }
 
+    @Override
     public DropTarget getTarget() {
         return dropTarget;
     }

src/com/vaadin/event/dd/acceptcriteria/AcceptAll.java

         return singleton;
     }
 
+    @Override
     public boolean accept(DragAndDropEvent dragEvent) {
         return true;
     }

src/com/vaadin/event/dd/acceptcriteria/And.java

         }
     }
 
+    @Override
     public boolean accept(DragAndDropEvent dragEvent) {
         for (ClientSideCriterion crit : criteria) {
             if (!crit.accept(dragEvent)) {

src/com/vaadin/event/dd/acceptcriteria/ClientSideCriterion.java

      * com.vaadin.event.dd.acceptCriteria.AcceptCriterion#isClientSideVerifiable
      * ()
      */
+    @Override
     public final boolean isClientSideVerifiable() {
         return true;
     }
 
+    @Override
     public void paint(PaintTarget target) throws PaintException {
         target.startTag("-ac");
         target.addAttribute("name", getIdentifier());
         return getClass().getCanonicalName();
     }
 
+    @Override
     public final void paintResponse(PaintTarget target) throws PaintException {
         // NOP, nothing to do as this is client side verified criterion
     }

src/com/vaadin/event/dd/acceptcriteria/ContainsDataFlavor.java

         target.addAttribute("p", dataFlavorId);
     }
 
+    @Override
     public boolean accept(DragAndDropEvent dragEvent) {
         return dragEvent.getTransferable().getDataFlavors()
                 .contains(dataFlavorId);

src/com/vaadin/event/dd/acceptcriteria/Not.java

         acceptCriterion.paint(target);
     }
 
+    @Override
     public boolean accept(DragAndDropEvent dragEvent) {
         return !acceptCriterion.accept(dragEvent);
     }

src/com/vaadin/event/dd/acceptcriteria/Or.java

         }
     }
 
+    @Override
     public boolean accept(DragAndDropEvent dragEvent) {
         for (AcceptCriterion crit : criteria) {
             if (crit.accept(dragEvent)) {

src/com/vaadin/event/dd/acceptcriteria/ServerSideCriterion.java

 
     private static final long serialVersionUID = 2128510128911628902L;
 
+    @Override
     public final boolean isClientSideVerifiable() {
         return false;
     }
 
+    @Override
     public void paint(PaintTarget target) throws PaintException {
         target.startTag("-ac");
         target.addAttribute("name", getIdentifier());
     public void paintContent(PaintTarget target) {
     }
 
+    @Override
     public void paintResponse(PaintTarget target) throws PaintException {
     }
 

src/com/vaadin/event/dd/acceptcriteria/SourceIs.java

         target.addAttribute("c", paintedComponents);
     }
 
+    @Override
     public boolean accept(DragAndDropEvent dragEvent) {
         if (dragEvent.getTransferable() instanceof TransferableImpl) {
             Component sourceComponent = ((TransferableImpl) dragEvent

src/com/vaadin/event/dd/acceptcriteria/SourceIsTarget.java

     private SourceIsTarget() {
     }
 
+    @Override
     public boolean accept(DragAndDropEvent dragEvent) {
         if (dragEvent.getTransferable() instanceof TransferableImpl) {
             Component sourceComponent = ((TransferableImpl) dragEvent

src/com/vaadin/event/dd/acceptcriteria/TargetDetailIs.java

         }
     }
 
+    @Override
     public boolean accept(DragAndDropEvent dragEvent) {
         Object data = dragEvent.getTargetDetails().getData(propertyName);
         return value.equals(data);

src/com/vaadin/external/json/JSONException.java

         this.cause = cause;
     }
 
+    @Override
     public Throwable getCause() {
         return this.cause;
     }

src/com/vaadin/external/json/JSONStringer.java

      * 
      * @return The JSON text.
      */
+    @Override
     public String toString() {
         return this.mode == 'd' ? this.writer.toString() : null;
     }

src/com/vaadin/navigator/Navigator.java

             setHeight("0px");
         }
 
+        @Override
         public void navigateTo(String fragmentParameters) {
             // nothing to do
         }
             page.addListener(this);
         }
 
+        @Override
         public String getFragment() {
             return page.getFragment();
         }
 
+        @Override
         public void setFragment(String fragment) {
             page.setFragment(fragment, false);
         }
 
+        @Override
         public void fragmentChanged(FragmentChangedEvent event) {
             UriFragmentManager.this.navigator.navigateTo(getFragment());
         }
             setSizeFull();
         }
 
+        @Override
         public void showView(View view) {
             if (view instanceof Component) {
                 setCompositionRoot((Component) view);
             this.container = container;
         }
 
+        @Override
         public void showView(View view) {
             if (view instanceof Component) {
                 container.removeAllComponents();
             this.view = view;
         }
 
+        @Override
         public String getViewName(String viewAndParameters) {
             if (null == viewAndParameters) {
                 return null;
             return null;
         }
 
+        @Override
         public View getView(String viewName) {
             if (this.viewName.equals(viewName)) {
                 return view;
             this.viewClass = viewClass;
         }
 
+        @Override
         public String getViewName(String viewAndParameters) {
             if (null == viewAndParameters) {
                 return null;
             return null;
         }
 
+        @Override
         public View getView(String viewName) {
             if (this.viewName.equals(viewName)) {
                 try {

src/com/vaadin/terminal/AbstractClientConnector.java

     private ClientConnector parent;
 
     /* Documentation copied from interface */
+    @Override
     public void requestRepaint() {
         Root root = getRoot();
         if (root != null) {
         registerRpc(implementation, type);
     }
 
+    @Override
     public SharedState getState() {
         if (null == sharedState) {
             sharedState = createState();
      * 
      * @see com.vaadin.terminal.gwt.server.ClientConnector#getStateType()
      */
+    @Override
     public Class<? extends SharedState> getStateType() {
         try {
             Method m = getClass().getMethod("getState", (Class[]) null);
             this.connector = connector;
         }
 
+        @Override
         public Iterator<ClientConnector> iterator() {
             CombinedIterator<ClientConnector> iterator = new CombinedIterator<ClientConnector>();
             iterator.addIterator(connector.getExtensions().iterator());
             rpcInterfaceName = rpcInterface.getName().replaceAll("\\$", ".");
         }
 
+        @Override
         public Object invoke(Object proxy, Method method, Object[] args)
                 throws Throwable {
             addMethodInvocationToQueue(rpcInterfaceName, method, args);
      * 
      * @since 7.0
      */
+    @Override
     public RpcManager getRpcManager(Class<?> rpcInterface) {
         return rpcManagerMap.get(rpcInterface);
     }
 
+    @Override
     public List<ClientMethodInvocation> retrievePendingRpcCalls() {
         if (pendingInvocations.isEmpty()) {
             return Collections.emptyList();
         }
     }
 
+    @Override
     public String getConnectorId() {
         if (connectorId == null) {
             if (getApplication() == null) {
      * @return the Root ancestor of this connector, or <code>null</code> if none
      *         is found.
      */
+    @Override
     public Root getRoot() {
         ClientConnector connector = this;
         while (connector != null) {
         return Logger.getLogger(AbstractClientConnector.class.getName());
     }
 
+    @Override
     public void requestRepaintAll() {
         requestRepaint();
 
             iterators.add(iterator);
         }
 
+        @Override
         public boolean hasNext() {
             for (Iterator<? extends T> i : iterators) {
                 if (i.hasNext()) {
             return false;
         }
 
+        @Override
         public T next() {
             for (Iterator<? extends T> i : iterators) {
                 if (i.hasNext()) {
             throw new NoSuchElementException();
         }
 
+        @Override
         public void remove() {
             throw new UnsupportedOperationException();
         }
         return new AllChildrenIterable(connector);
     }
 
+    @Override
     public Collection<Extension> getExtensions() {
         return Collections.unmodifiableCollection(extensions);
     }
         requestRepaint();
     }
 
+    @Override
     public void removeExtension(Extension extension) {
         extension.setParent(null);
         extensions.remove(extension);
         requestRepaint();
     }
 
+    @Override
     public void setParent(ClientConnector parent) {
 
         // If the parent is not changed, don't do anything
         }
     }
 
+    @Override
     public ClientConnector getParent() {
         return parent;
     }
 
+    @Override
     public void attach() {
         requestRepaint();
 
      * <code>null</code> after this method is called.
      * </p>
      */
+    @Override
     public void detach() {
         for (ClientConnector connector : getAllChildrenIterable(this)) {
             connector.detach();
         getRoot().getConnectorTracker().unregisterConnector(this);
     }
 
+    @Override
     public boolean isConnectorEnabled() {
         if (getParent() == null) {
             // No parent -> the component cannot receive updates from the client

src/com/vaadin/terminal/AbstractErrorMessage.java

     }
 
     /* Documented in interface */
+    @Override
     public ErrorLevel getErrorLevel() {
         return level;
     }
         causes.add(cause);
     }
 
+    @Override
     public String getFormattedHtmlMessage() {
         String result = null;
         switch (getMode()) {

src/com/vaadin/terminal/ClassResource.java

      * 
      * @see com.vaadin.terminal.Resource#getMIMEType()
      */
+    @Override
     public String getMIMEType() {
         return FileTypeResolver.getMIMEType(resourceName);
     }
      * 
      * @see com.vaadin.terminal.ApplicationResource#getApplication()
      */
+    @Override
     public Application getApplication() {
         return application;
     }
      * @return the file name associated to this resource.
      * @see com.vaadin.terminal.ApplicationResource#getFilename()
      */
+    @Override
     public String getFilename() {
         int index = 0;
         int next = 0;
      * 
      * @see com.vaadin.terminal.ApplicationResource#getStream()
      */
+    @Override
     public DownloadStream getStream() {
         final DownloadStream ds = new DownloadStream(
                 associatedClass.getResourceAsStream(resourceName),
     }
 
     /* documented in superclass */
+    @Override
     public int getBufferSize() {
         return bufferSize;
     }
     }
 
     /* documented in superclass */
+    @Override
     public long getCacheTime() {
         return cacheTime;
     }

src/com/vaadin/terminal/CombinedRequest.java

 
     }
 
+    @Override
     public String getParameter(String parameter) {
         String[] strings = getParameterMap().get(parameter);
         if (strings == null || strings.length == 0) {
         }
     }
 
+    @Override
     public Map<String, String[]> getParameterMap() {
         return parameterMap;
     }
 
+    @Override
     public int getContentLength() {
         return secondRequest.getContentLength();
     }
 
+    @Override
     public InputStream getInputStream() throws IOException {
         return secondRequest.getInputStream();
     }
 
+    @Override
     public Object getAttribute(String name) {
         return secondRequest.getAttribute(name);
     }
 
+    @Override
     public void setAttribute(String name, Object value) {
         secondRequest.setAttribute(name, value);
     }
 
+    @Override
     public String getRequestPathInfo() {
         return secondRequest.getParameter("initialPath");
     }
 
+    @Override
     public int getSessionMaxInactiveInterval() {
         return secondRequest.getSessionMaxInactiveInterval();
     }
 
+    @Override
     public Object getSessionAttribute(String name) {
         return secondRequest.getSessionAttribute(name);
     }
 
+    @Override
     public void setSessionAttribute(String name, Object attribute) {
         secondRequest.setSessionAttribute(name, attribute);
     }
 
+    @Override
     public String getContentType() {
         return secondRequest.getContentType();
     }
 
+    @Override
     public BrowserDetails getBrowserDetails() {
         return new BrowserDetails() {
+            @Override
             public String getUriFragment() {
                 String fragment = secondRequest.getParameter("fr");
                 if (fragment == null) {
                 }
             }
 
+            @Override
             public String getWindowName() {
                 return secondRequest.getParameter("wn");
             }
 
+            @Override
             public WebBrowser getWebBrowser() {
                 WebApplicationContext context = (WebApplicationContext) Application
                         .getCurrent().getContext();
         return secondRequest;
     }
 
+    @Override
     public Locale getLocale() {
         return secondRequest.getLocale();
     }
 
+    @Override
     public String getRemoteAddr() {
         return secondRequest.getRemoteAddr();
     }
 
+    @Override
     public boolean isSecure() {
         return secondRequest.isSecure();
     }
 
+    @Override
     public String getHeader(String name) {
         return secondRequest.getHeader(name);
     }
 
+    @Override
     public DeploymentConfiguration getDeploymentConfiguration() {
         return secondRequest.getDeploymentConfiguration();
     }

src/com/vaadin/terminal/ExternalResource.java

      * 
      * @see com.vaadin.terminal.Resource#getMIMEType()
      */
+    @Override
     public String getMIMEType() {
         if (mimeType == null) {
             mimeType = FileTypeResolver.getMIMEType(getURL().toString());

src/com/vaadin/terminal/FileResource.java

      * 
      * @see com.vaadin.terminal.ApplicationResource#getStream()
      */
+    @Override
     public DownloadStream getStream() {
         try {
             final DownloadStream ds = new DownloadStream(new FileInputStream(
             // Log the exception using the application error handler
             getApplication().getErrorHandler().terminalError(new ErrorEvent() {
 
+                @Override
                 public Throwable getThrowable() {
                     return e;
                 }
     /**
      * @see com.vaadin.terminal.ApplicationResource#getApplication()
      */
+    @Override
     public Application getApplication() {
         return application;
     }
     /**
      * @see com.vaadin.terminal.ApplicationResource#getFilename()
      */
+    @Override
     public String getFilename() {
         return sourceFile.getName();
     }
     /**
      * @see com.vaadin.terminal.Resource#getMIMEType()
      */
+    @Override
     public String getMIMEType() {
         return FileTypeResolver.getMIMEType(sourceFile);
     }
      * 
      * @return Cache time in milliseconds.
      */
+    @Override
     public long getCacheTime() {
         return cacheTime;
     }
     }
 
     /* documented in superclass */
+    @Override
     public int getBufferSize() {
         return bufferSize;
     }

src/com/vaadin/terminal/JavaScriptCallbackHelper.java

     private void ensureRpc() {
         if (javascriptCallbackRpc == null) {
             javascriptCallbackRpc = new JavaScriptCallbackRpc() {
+                @Override
                 public void call(String name, JSONArray arguments) {
                     JavaScriptCallback callback = callbacks.get(name);
                     try {

src/com/vaadin/terminal/StreamResource.java

     /**
      * @see com.vaadin.terminal.Resource#getMIMEType()
      */
+    @Override
     public String getMIMEType() {
         if (MIMEType != null) {
             return MIMEType;
      * 
      * @return the filename.
      */
+    @Override
     public String getFilename() {
         return filename;
     }
     /**
      * @see com.vaadin.terminal.ApplicationResource#getApplication()
      */
+    @Override
     public Application getApplication() {
         return application;
     }
     /**
      * @see com.vaadin.terminal.ApplicationResource#getStream()
      */
+    @Override
     public DownloadStream getStream() {
         final StreamSource ss = getStreamSource();
         if (ss == null) {
     }
 
     /* documented in superclass */
+    @Override
     public int getBufferSize() {
         return bufferSize;
     }
     }
 
     /* documented in superclass */
+    @Override
     public long getCacheTime() {
         return cacheTime;
     }

src/com/vaadin/terminal/ThemeResource.java

     /**
      * @see com.vaadin.terminal.Resource#getMIMEType()
      */
+    @Override
     public String getMIMEType() {
         return FileTypeResolver.getMIMEType(getResourceId());
     }

src/com/vaadin/terminal/gwt/client/AbstractFieldState.java

      * 
      * @see com.vaadin.terminal.gwt.client.ComponentState#getTabIndex()
      */
+    @Override
     public int getTabIndex() {
         return tabIndex;
     }
      * 
      * @see com.vaadin.terminal.gwt.client.ui.TabIndexState#setTabIndex(int)
      */
+    @Override
     public void setTabIndex(int tabIndex) {
         this.tabIndex = tabIndex;
     }

src/com/vaadin/terminal/gwt/client/ApplicationConfiguration.java

     public static void startApplication(final String applicationId) {
         Scheduler.get().scheduleDeferred(new ScheduledCommand() {
 
+            @Override
             public void execute() {
                 ApplicationConfiguration appConf = getConfigFromDOM(applicationId);
                 ApplicationConnection a = GWT
 
     private static DeferredWidgetLoader deferredWidgetLoader;
 
+    @Override
     public void onModuleLoad() {
 
         // Prepare VConsole for debugging
          */
         GWT.setUncaughtExceptionHandler(new UncaughtExceptionHandler() {
 
+            @Override
             public void onUncaughtException(Throwable e) {
                 /*
                  * Note in case of null console (without ?debug) we eat

src/com/vaadin/terminal/gwt/client/ComponentConnector.java

      * 
      * @see com.vaadin.terminal.gwt.client.VPaintable#getState()
      */
+    @Override
     public ComponentState getState();
 
     /**

src/com/vaadin/terminal/gwt/client/JavaScriptConnectorHelper.java

 
     public void init() {
         connector.addStateChangeHandler(new StateChangeHandler() {
+            @Override
             public void onStateChanged(StateChangeEvent stateChangeEvent) {
                 JavaScriptObject wrapper = getConnectorWrapper();
                 JavaScriptConnectorState state = getConnectorState();

src/com/vaadin/terminal/gwt/client/JavaScriptExtension.java

         helper.init();
     }
 
+    @Override
     public JavaScriptConnectorHelper getJavascriptConnectorHelper() {
         return helper;
     }

src/com/vaadin/terminal/gwt/client/JavaScriptExtensionState.java

     private Set<String> callbackNames = new HashSet<String>();
     private Map<String, Set<String>> rpcInterfaces = new HashMap<String, Set<String>>();
 
+    @Override
     public Set<String> getCallbackNames() {
         return callbackNames;
     }
         this.callbackNames = callbackNames;
     }
 
+    @Override
     public Map<String, Set<String>> getRpcInterfaces() {
         return rpcInterfaces;
     }

src/com/vaadin/terminal/gwt/client/NullConsole.java

  */
 public class NullConsole implements Console {
 
+    @Override
     public void dirUIDL(ValueMap u, ApplicationConfiguration cnf) {
     }
 
+    @Override
     public void error(String msg) {
         GWT.log(msg);
     }
 
+    @Override
     public void log(String msg) {
         GWT.log(msg);
     }
 
+    @Override
     public void printObject(Object msg) {
         GWT.log(msg.toString());
     }
 
+    @Override
     public void printLayoutProblems(ValueMap meta,
             ApplicationConnection applicationConnection,
             Set<ComponentConnector> zeroHeightComponents,
             Set<ComponentConnector> zeroWidthComponents) {
     }
 
+    @Override
     public void log(Throwable e) {
         GWT.log(e.getMessage(), e);
     }
 
+    @Override
     public void error(Throwable e) {
         // Borrow exception handling from VDebugConsole
         VDebugConsole.handleError(e, this);
     }
 
+    @Override
     public void setQuietMode(boolean quietDebugMode) {
     }
 
+    @Override
     public void init() {
     }
 

src/com/vaadin/terminal/gwt/client/ResourceLoader.java

         if (preloadListeners.containsKey(url)) {
             // Preload going on, continue when preloaded
             preloadResource(url, new ResourceLoadListener() {
+                @Override
                 public void onLoad(ResourceLoadEvent event) {
                     loadScript(url, resourceLoadListener);
                 }
 
+                @Override
                 public void onError(ResourceLoadEvent event) {
                     // Preload failed -> signal error to own listener
                     if (resourceLoadListener != null) {
             scriptTag.setSrc(url);
             scriptTag.setType("text/javascript");
             addOnloadHandler(scriptTag, new ResourceLoadListener() {
+                @Override
                 public void onLoad(ResourceLoadEvent event) {
                     fireLoad(event);
                 }
 
+                @Override
                 public void onError(ResourceLoadEvent event) {
                     fireError(event);
                 }
 
             Element element = getPreloadElement(url);
             addOnloadHandler(element, new ResourceLoadListener() {
+                @Override
                 public void onLoad(ResourceLoadEvent event) {
                     fireLoad(event);
                 }
 
+                @Override
                 public void onError(ResourceLoadEvent event) {
                     fireError(event);
                 }
         if (preloadListeners.containsKey(url)) {
             // Preload going on, continue when preloaded
             preloadResource(url, new ResourceLoadListener() {
+                @Override
                 public void onLoad(ResourceLoadEvent event) {
                     loadStylesheet(url, resourceLoadListener);
                 }
 
+                @Override
                 public void onError(ResourceLoadEvent event) {
                     // Preload failed -> signal error to own listener
                     if (resourceLoadListener != null) {
                 Scheduler.get().scheduleFixedPeriod(new RepeatingCommand() {
                     private final Duration duration = new Duration();
 
+                    @Override
                     public boolean execute() {
                         int styleSheetLength = getStyleSheetLength(url);
                         if (getStyleSheetLength(url) > 0) {
                 }, 10);
             } else {
                 addOnloadHandler(linkElement, new ResourceLoadListener() {
+                    @Override
                     public void onLoad(ResourceLoadEvent event) {
                         // Chrome && IE fires load for errors, must check
                         // stylesheet data
                         fireLoad(event);
                     }
 
+                    @Override
                     public void onError(ResourceLoadEvent event) {
                         fireError(event);
                     }

src/com/vaadin/terminal/gwt/client/ServerConnector.java

      * @return The parent of this connector, as set by
      *         {@link #setParent(ServerConnector)}.
      */
+    @Override
     public ServerConnector getParent();
 
     /**