@@ -389,7 +389,7 @@ public class GridConnector extends AbstractHasComponentsConnector | |||
} else { | |||
Collection<Column<?, JsonObject>> errorColumns; | |||
if (errorColumnsIds != null) { | |||
errorColumns = new ArrayList<>(); | |||
errorColumns = new ArrayList<Column<?, JsonObject>>(); | |||
for (String colId : errorColumnsIds) { | |||
errorColumns.add(columnIdToColumn.get(colId)); | |||
} | |||
@@ -435,7 +435,7 @@ public class GridConnector extends AbstractHasComponentsConnector | |||
public void onColumnReorder(ColumnReorderEvent<JsonObject> event) { | |||
if (!columnsUpdatedFromState) { | |||
List<Column<?, JsonObject>> columns = getWidget().getColumns(); | |||
final List<String> newColumnOrder = new ArrayList<>(); | |||
final List<String> newColumnOrder = new ArrayList<String>(); | |||
for (Column<?, JsonObject> column : columns) { | |||
if (column instanceof CustomGridColumn) { | |||
newColumnOrder.add(((CustomGridColumn) column).id); | |||
@@ -494,8 +494,8 @@ public class GridConnector extends AbstractHasComponentsConnector | |||
private class CustomDetailsGenerator | |||
implements HeightAwareDetailsGenerator { | |||
private final Map<String, ComponentConnector> idToDetailsMap = new HashMap<>(); | |||
private final Map<String, Integer> idToRowIndex = new HashMap<>(); | |||
private final Map<String, ComponentConnector> idToDetailsMap = new HashMap<String, ComponentConnector>(); | |||
private final Map<String, Integer> idToRowIndex = new HashMap<String, Integer>(); | |||
@Override | |||
public Widget getDetails(int rowIndex) { | |||
@@ -544,7 +544,7 @@ public class GridConnector extends AbstractHasComponentsConnector | |||
} | |||
public void updateConnectorHierarchy(List<ServerConnector> children) { | |||
Set<String> connectorIds = new HashSet<>(); | |||
Set<String> connectorIds = new HashSet<String>(); | |||
for (ServerConnector child : children) { | |||
if (child instanceof ComponentConnector) { | |||
connectorIds.add(child.getConnectorId()); | |||
@@ -553,7 +553,7 @@ public class GridConnector extends AbstractHasComponentsConnector | |||
} | |||
} | |||
Set<String> removedDetails = new HashSet<>(); | |||
Set<String> removedDetails = new HashSet<String>(); | |||
for (Entry<String, ComponentConnector> entry : idToDetailsMap | |||
.entrySet()) { | |||
ComponentConnector connector = entry.getValue(); | |||
@@ -626,9 +626,9 @@ public class GridConnector extends AbstractHasComponentsConnector | |||
/** | |||
* Maps a generated column id to a grid column instance | |||
*/ | |||
private Map<String, CustomGridColumn> columnIdToColumn = new HashMap<>(); | |||
private Map<String, CustomGridColumn> columnIdToColumn = new HashMap<String, CustomGridColumn>(); | |||
private List<String> columnOrder = new ArrayList<>(); | |||
private List<String> columnOrder = new ArrayList<String>(); | |||
/** | |||
* {@link #columnsUpdatedFromState} is set to true when | |||
@@ -642,7 +642,7 @@ public class GridConnector extends AbstractHasComponentsConnector | |||
private RpcDataSource dataSource; | |||
/* Used to track Grid editor columns with validation errors */ | |||
private final Map<Column<?, JsonObject>, String> columnToErrorMessage = new HashMap<>(); | |||
private final Map<Column<?, JsonObject>, String> columnToErrorMessage = new HashMap<Column<?, JsonObject>, String>(); | |||
private ItemClickHandler itemClickHandler = new ItemClickHandler(); | |||
@@ -1106,7 +1106,7 @@ public class GridConnector extends AbstractHasComponentsConnector | |||
private void purgeRemovedColumns() { | |||
// Get columns still registered in the state | |||
Set<String> columnsInState = new HashSet<>(); | |||
Set<String> columnsInState = new HashSet<String>(); | |||
for (GridColumnState columnState : getState().columns) { | |||
columnsInState.add(columnState.id); | |||
} | |||
@@ -1131,7 +1131,7 @@ public class GridConnector extends AbstractHasComponentsConnector | |||
} | |||
private void onSortStateChange() { | |||
List<SortOrder> sortOrder = new ArrayList<>(); | |||
List<SortOrder> sortOrder = new ArrayList<SortOrder>(); | |||
String[] sortColumns = getState().sortColumns; | |||
SortDirection[] sortDirs = getState().sortDirs; | |||
@@ -1288,7 +1288,7 @@ public class GridConnector extends AbstractHasComponentsConnector | |||
* @return displayed error string | |||
*/ | |||
private String getColumnErrors() { | |||
List<String> errors = new ArrayList<>(); | |||
List<String> errors = new ArrayList<String>(); | |||
for (Grid.Column<?, JsonObject> c : getWidget().getColumns()) { | |||
if (!(c instanceof CustomGridColumn)) { |
@@ -73,7 +73,7 @@ public class RpcDataSourceConnector extends AbstractExtensionConnector { | |||
registerRpc(DataProviderRpc.class, new DataProviderRpc() { | |||
@Override | |||
public void setRowData(int firstRow, JsonArray rowArray) { | |||
ArrayList<JsonObject> rows = new ArrayList<>( | |||
ArrayList<JsonObject> rows = new ArrayList<JsonObject>( | |||
rowArray.length()); | |||
for (int i = 0; i < rowArray.length(); i++) { | |||
JsonObject rowObject = rowArray.getObject(i); |
@@ -368,15 +368,15 @@ public class VCalendar extends Composite implements VHasDropHandler { | |||
e.onselectstart = function() { | |||
return false; | |||
} | |||
e.ondragstart = function() { | |||
return false; | |||
} | |||
}-*/; | |||
private void updateEventsToWeekGrid(CalendarEvent[] events) { | |||
List<CalendarEvent> allDayLong = new ArrayList<>(); | |||
List<CalendarEvent> belowDayLong = new ArrayList<>(); | |||
List<CalendarEvent> allDayLong = new ArrayList<CalendarEvent>(); | |||
List<CalendarEvent> belowDayLong = new ArrayList<CalendarEvent>(); | |||
for (CalendarEvent e : events) { | |||
if (e.isAllDay()) { | |||
@@ -421,8 +421,8 @@ public class VCalendar extends Composite implements VHasDropHandler { | |||
boolean eventAdded = false; | |||
boolean inProgress = false; // Event adding has started | |||
boolean eventMoving = false; | |||
List<SimpleDayCell> dayCells = new ArrayList<>(); | |||
List<SimpleDayCell> timeCells = new ArrayList<>(); | |||
List<SimpleDayCell> dayCells = new ArrayList<SimpleDayCell>(); | |||
List<SimpleDayCell> timeCells = new ArrayList<SimpleDayCell>(); | |||
for (int row = 0; row < monthGrid.getRowCount(); row++) { | |||
if (eventAdded) { | |||
break; | |||
@@ -570,7 +570,7 @@ public class VCalendar extends Composite implements VHasDropHandler { | |||
/** | |||
* Sort the events by current sort order | |||
* | |||
* | |||
* @param events | |||
* The events to sort | |||
* @return An array where the events has been sorted | |||
@@ -599,7 +599,7 @@ public class VCalendar extends Composite implements VHasDropHandler { | |||
/** | |||
* Sort the event by how long they are | |||
* | |||
* | |||
* @param events | |||
* The events to sort | |||
* @return An array where the events has been sorted | |||
@@ -968,11 +968,11 @@ public class VCalendar extends Composite implements VHasDropHandler { | |||
/** | |||
* Returns the default comparator which can compare calendar events by | |||
* duration. | |||
* | |||
* | |||
* @deprecated this returns just one default comparator, but there are | |||
* number of comparators that are used to sort events depending | |||
* on order. | |||
* | |||
* | |||
* @return | |||
*/ | |||
@Deprecated | |||
@@ -1611,7 +1611,7 @@ public class VCalendar extends Composite implements VHasDropHandler { | |||
/** | |||
* Set sort strategy for events. | |||
* | |||
* | |||
* @param order | |||
* sort order | |||
*/ | |||
@@ -1625,7 +1625,7 @@ public class VCalendar extends Composite implements VHasDropHandler { | |||
/** | |||
* Return currently active sort order. | |||
* | |||
* | |||
* @return current sort order | |||
*/ | |||
public EventSortOrder getSortOrder() { |
@@ -243,12 +243,12 @@ public class VFilterSelect extends Composite | |||
return $entry(function(e) { | |||
var deltaX = e.deltaX ? e.deltaX : -0.5*e.wheelDeltaX; | |||
var deltaY = e.deltaY ? e.deltaY : -0.5*e.wheelDeltaY; | |||
// IE8 has only delta y | |||
if (isNaN(deltaY)) { | |||
deltaY = -0.5*e.wheelDelta; | |||
} | |||
@com.vaadin.v7.client.ui.VFilterSelect.JsniUtil::moveScrollFromEvent(*)(widget, deltaX, deltaY, e, e.deltaMode); | |||
}); | |||
}-*/; | |||
@@ -1473,7 +1473,7 @@ public class VFilterSelect extends Composite | |||
* <p> | |||
* For internal use only. May be removed or replaced in the future. | |||
*/ | |||
public final List<FilterSelectSuggestion> currentSuggestions = new ArrayList<>(); | |||
public final List<FilterSelectSuggestion> currentSuggestions = new ArrayList<FilterSelectSuggestion>(); | |||
/** For internal use only. May be removed or replaced in the future. */ | |||
public boolean immediate; | |||
@@ -1957,7 +1957,7 @@ public class VFilterSelect extends Composite | |||
Unit.PX); | |||
} | |||
private static Set<Integer> navigationKeyCodes = new HashSet<>(); | |||
private static Set<Integer> navigationKeyCodes = new HashSet<Integer>(); | |||
static { | |||
navigationKeyCodes.add(KeyCodes.KEY_DOWN); | |||
navigationKeyCodes.add(KeyCodes.KEY_UP); |
@@ -95,8 +95,8 @@ public class VOptionGroup extends VOptionGroupBase | |||
public VOptionGroup() { | |||
super(CLASSNAME); | |||
panel = (Panel) optionsContainer; | |||
optionsToKeys = new HashMap<>(); | |||
optionsEnabled = new HashMap<>(); | |||
optionsToKeys = new HashMap<CheckBox, String>(); | |||
optionsEnabled = new HashMap<CheckBox, Boolean>(); | |||
wasMultiselect = isMultiselect(); | |||
} | |||
@@ -113,12 +113,12 @@ public class VOptionGroup extends VOptionGroupBase | |||
* rebuilt (losing focus) if number of elements or their order is | |||
* changed. | |||
*/ | |||
HashMap<String, CheckBox> keysToOptions = new HashMap<>(); | |||
HashMap<String, CheckBox> keysToOptions = new HashMap<String, CheckBox>(); | |||
for (Map.Entry<CheckBox, String> entry : optionsToKeys.entrySet()) { | |||
keysToOptions.put(entry.getValue(), entry.getKey()); | |||
} | |||
ArrayList<Widget> existingwidgets = new ArrayList<>(); | |||
ArrayList<Widget> newwidgets = new ArrayList<>(); | |||
ArrayList<Widget> existingwidgets = new ArrayList<Widget>(); | |||
ArrayList<Widget> newwidgets = new ArrayList<Widget>(); | |||
// Get current order of elements | |||
for (Widget wid : panel) { |
@@ -90,8 +90,8 @@ public class CalendarConnector extends AbstractLegacyComponentConnector | |||
private CalendarServerRpc rpc = RpcProxy.create(CalendarServerRpc.class, | |||
this); | |||
private final HashMap<String, String> actionMap = new HashMap<>(); | |||
private HashMap<Object, String> tooltips = new HashMap<>(); | |||
private final HashMap<String, String> actionMap = new HashMap<String, String>(); | |||
private HashMap<Object, String> tooltips = new HashMap<Object, String>(); | |||
private static final String DROPHANDLER_ACCEPT_CRITERIA_PAINT_TAG = "-ac"; | |||
@@ -498,8 +498,8 @@ public class CalendarConnector extends AbstractLegacyComponentConnector | |||
} | |||
private Action[] getActionsBetween(Date start, Date end) { | |||
List<Action> actions = new ArrayList<>(); | |||
List<String> ids = new ArrayList<>(); | |||
List<Action> actions = new ArrayList<Action>(); | |||
List<String> ids = new ArrayList<String>(); | |||
for (int i = 0; i < actionKeys.size(); i++) { | |||
String actionKey = actionKeys.get(i); | |||
@@ -554,7 +554,7 @@ public class CalendarConnector extends AbstractLegacyComponentConnector | |||
return actions.toArray(new Action[actions.size()]); | |||
} | |||
private List<String> actionKeys = new ArrayList<>(); | |||
private List<String> actionKeys = new ArrayList<String>(); | |||
private void updateActionMap(List<CalendarState.Action> actions) { | |||
actionMap.clear(); | |||
@@ -653,7 +653,7 @@ public class CalendarConnector extends AbstractLegacyComponentConnector | |||
*/ | |||
@Override | |||
public Action[] getActions() { | |||
List<Action> actions = new ArrayList<>(); | |||
List<Action> actions = new ArrayList<Action>(); | |||
for (int i = 0; i < actionKeys.size(); i++) { | |||
final String actionKey = actionKeys.get(i); | |||
final VCalendarAction a = new VCalendarAction(this, rpc, actionKey); | |||
@@ -684,7 +684,7 @@ public class CalendarConnector extends AbstractLegacyComponentConnector | |||
private List<CalendarEvent> calendarEventListOf( | |||
List<CalendarState.Event> events, boolean format24h) { | |||
List<CalendarEvent> list = new ArrayList<>(events.size()); | |||
List<CalendarEvent> list = new ArrayList<CalendarEvent>(events.size()); | |||
for (CalendarState.Event event : events) { | |||
final String dateFrom = event.dateFrom; | |||
final String dateTo = event.dateTo; | |||
@@ -709,7 +709,7 @@ public class CalendarConnector extends AbstractLegacyComponentConnector | |||
} | |||
private List<CalendarDay> calendarDayListOf(List<CalendarState.Day> days) { | |||
List<CalendarDay> list = new ArrayList<>(days.size()); | |||
List<CalendarDay> list = new ArrayList<CalendarDay>(days.size()); | |||
for (CalendarState.Day day : days) { | |||
CalendarDay d = new CalendarDay(day.date, day.localizedDateFormat, | |||
day.dayOfWeek, day.week, day.yearOfWeek); |
@@ -56,7 +56,7 @@ public class DateCell extends FocusableComplexPanel implements MouseDownHandler, | |||
private boolean disabled = false; | |||
private int height; | |||
private final Element[] slotElements; | |||
private final List<DateCellSlot> slots = new ArrayList<>(); | |||
private final List<DateCellSlot> slots = new ArrayList<DateCellSlot>(); | |||
private int[] slotElementHeights; | |||
private int startingSlotHeight; | |||
private Date today; | |||
@@ -104,7 +104,7 @@ public class DateCell extends FocusableComplexPanel implements MouseDownHandler, | |||
addStyleName("v-calendar-day-times"); | |||
handlers = new LinkedList<>(); | |||
handlers = new LinkedList<HandlerRegistration>(); | |||
// 2 slots / hour | |||
firstHour = weekgrid.getFirstHour(); | |||
@@ -278,11 +278,11 @@ public class DateCell extends FocusableComplexPanel implements MouseDownHandler, | |||
} | |||
public void recalculateEventWidths() { | |||
List<DateCellGroup> groups = new ArrayList<>(); | |||
List<DateCellGroup> groups = new ArrayList<DateCellGroup>(); | |||
int count = getWidgetCount(); | |||
List<Integer> handled = new ArrayList<>(); | |||
List<Integer> handled = new ArrayList<Integer>(); | |||
// Iterate through all events and group them. Events that overlaps | |||
// with each other, are added to the same group. | |||
@@ -345,8 +345,8 @@ public class DateCell extends FocusableComplexPanel implements MouseDownHandler, | |||
for (DateCellGroup g : groups) { | |||
int col = 0; | |||
int colCount = 0; | |||
List<Integer> order = new ArrayList<>(); | |||
Map<Integer, Integer> columns = new HashMap<>(); | |||
List<Integer> order = new ArrayList<Integer>(); | |||
Map<Integer, Integer> columns = new HashMap<Integer, Integer>(); | |||
for (Integer eventIndex : g.getItems()) { | |||
DateCellDayEvent d = (DateCellDayEvent) getWidget(eventIndex); | |||
d.setMoveWidth(width); | |||
@@ -534,7 +534,7 @@ public class DateCell extends FocusableComplexPanel implements MouseDownHandler, | |||
public void addEvent(DateCellDayEvent dayEvent) { | |||
Element main = getElement(); | |||
int index = 0; | |||
List<CalendarEvent> events = new ArrayList<>(); | |||
List<CalendarEvent> events = new ArrayList<CalendarEvent>(); | |||
// events are the only widgets in this panel | |||
// slots are just elements |
@@ -124,7 +124,7 @@ public class ComboBoxConnector extends AbstractFieldConnector | |||
getWidget().totalMatches = 0; | |||
} | |||
List<FilterSelectSuggestion> newSuggestions = new ArrayList<>(); | |||
List<FilterSelectSuggestion> newSuggestions = new ArrayList<FilterSelectSuggestion>(); | |||
for (final Iterator<?> i = options.getChildIterator(); i.hasNext();) { | |||
final UIDL optionUidl = (UIDL) i.next(); |
@@ -326,7 +326,7 @@ public class ListDataSource<T> implements DataSource<T> { | |||
/** | |||
* Handler for listening to changes in the underlying list. | |||
*/ | |||
private Set<DataChangeHandler> changeHandlers = new LinkedHashSet<>(); | |||
private Set<DataChangeHandler> changeHandlers = new LinkedHashSet<DataChangeHandler>(); | |||
/** | |||
* Constructs a new list data source. | |||
@@ -344,7 +344,7 @@ public class ListDataSource<T> implements DataSource<T> { | |||
if (datasource == null) { | |||
throw new IllegalArgumentException("datasource cannot be null"); | |||
} | |||
ds = new ArrayList<>(datasource); | |||
ds = new ArrayList<T>(datasource); | |||
wrapper = new ListWrapper(); | |||
} | |||
@@ -358,9 +358,9 @@ public class ListDataSource<T> implements DataSource<T> { | |||
*/ | |||
public ListDataSource(T... rows) { | |||
if (rows == null) { | |||
ds = new ArrayList<>(); | |||
ds = new ArrayList<T>(); | |||
} else { | |||
ds = new ArrayList<>(Arrays.asList(rows)); | |||
ds = new ArrayList<T>(Arrays.asList(rows)); | |||
} | |||
wrapper = new ListWrapper(); | |||
} | |||
@@ -463,7 +463,8 @@ public class ListDataSource<T> implements DataSource<T> { | |||
} | |||
private Stream<DataChangeHandler> getHandlers() { | |||
Set<DataChangeHandler> copy = new LinkedHashSet<>(changeHandlers); | |||
Set<DataChangeHandler> copy = new LinkedHashSet<DataChangeHandler>( | |||
changeHandlers); | |||
return copy.stream(); | |||
} | |||
@@ -425,7 +425,7 @@ public class GAEVaadinServlet extends VaadinServlet { | |||
getLogger().log(Level.INFO, | |||
"Vaadin cleanup deleting {0} expired Vaadin sessions.", | |||
entities.size()); | |||
List<Key> keys = new ArrayList<>(); | |||
List<Key> keys = new ArrayList<Key>(); | |||
for (Entity e : entities) { | |||
keys.add(e.getKey()); | |||
} | |||
@@ -445,7 +445,7 @@ public class GAEVaadinServlet extends VaadinServlet { | |||
getLogger().log(Level.INFO, | |||
"Vaadin cleanup deleting {0} expired appengine sessions.", | |||
entities.size()); | |||
List<Key> keys = new ArrayList<>(); | |||
List<Key> keys = new ArrayList<Key>(); | |||
for (Entity e : entities) { | |||
keys.add(e.getKey()); | |||
} |
@@ -84,7 +84,7 @@ public class ContainerHelpers implements Serializable { | |||
endIndex = container.size(); | |||
} | |||
ArrayList<Object> rangeOfIds = new ArrayList<>(); | |||
ArrayList<Object> rangeOfIds = new ArrayList<Object>(); | |||
for (int i = startIndex; i < endIndex; i++) { | |||
Object idByIndex = container.getIdByIndex(i); | |||
if (idByIndex == null) { |
@@ -36,7 +36,7 @@ public class BeanFieldGroup<T> extends FieldGroup { | |||
public BeanFieldGroup(Class<T> beanType) { | |||
this.beanType = beanType; | |||
this.defaultValidators = new HashMap<>(); | |||
this.defaultValidators = new HashMap<Field<?>, BeanValidator>(); | |||
} | |||
@Override | |||
@@ -117,7 +117,7 @@ public class BeanFieldGroup<T> extends FieldGroup { | |||
if (bean == null) { | |||
setItemDataSource((Item) null); | |||
} else { | |||
setItemDataSource(new BeanItem<>(bean, beanType)); | |||
setItemDataSource(new BeanItem<T>(bean, beanType)); | |||
} | |||
} | |||
@@ -260,7 +260,7 @@ public class BeanFieldGroup<T> extends FieldGroup { | |||
private static <T> BeanFieldGroup<T> createAndBindFields(T bean, | |||
Object objectWithMemberFields, boolean buffered) { | |||
@SuppressWarnings("unchecked") | |||
BeanFieldGroup<T> beanFieldGroup = new BeanFieldGroup<>( | |||
BeanFieldGroup<T> beanFieldGroup = new BeanFieldGroup<T>( | |||
(Class<T>) bean.getClass()); | |||
beanFieldGroup.setItemDataSource(bean); | |||
beanFieldGroup.setBuffered(buffered); |
@@ -61,9 +61,9 @@ public class FieldGroup implements Serializable { | |||
private boolean enabled = true; | |||
private boolean readOnly = false; | |||
private HashMap<Object, Field<?>> propertyIdToField = new HashMap<>(); | |||
private LinkedHashMap<Field<?>, Object> fieldToPropertyId = new LinkedHashMap<>(); | |||
private List<CommitHandler> commitHandlers = new ArrayList<>(); | |||
private HashMap<Object, Field<?>> propertyIdToField = new HashMap<Object, Field<?>>(); | |||
private LinkedHashMap<Field<?>, Object> fieldToPropertyId = new LinkedHashMap<Field<?>, Object>(); | |||
private List<CommitHandler> commitHandlers = new ArrayList<CommitHandler>(); | |||
/** | |||
* The field factory used by builder methods. | |||
@@ -104,7 +104,7 @@ public class FieldGroup implements Serializable { | |||
/** | |||
* Binds all fields to the properties in the item in use. | |||
* | |||
* | |||
* @since 7.7.5 | |||
*/ | |||
protected void bindFields() { | |||
@@ -303,7 +303,7 @@ public class FieldGroup implements Serializable { | |||
*/ | |||
protected <T> Property.Transactional<T> wrapInTransactionalProperty( | |||
Property<T> itemProperty) { | |||
return new TransactionalPropertyWrapper<>(itemProperty); | |||
return new TransactionalPropertyWrapper<T>(itemProperty); | |||
} | |||
private void throwIfFieldIsNull(Field<?> field, Object propertyId) { | |||
@@ -462,9 +462,9 @@ public class FieldGroup implements Serializable { | |||
*/ | |||
public Collection<Object> getUnboundPropertyIds() { | |||
if (getItemDataSource() == null) { | |||
return new ArrayList<>(); | |||
return new ArrayList<Object>(); | |||
} | |||
List<Object> unboundPropertyIds = new ArrayList<>(); | |||
List<Object> unboundPropertyIds = new ArrayList<Object>(); | |||
unboundPropertyIds.addAll(getItemDataSource().getItemPropertyIds()); | |||
unboundPropertyIds.removeAll(propertyIdToField.keySet()); | |||
return unboundPropertyIds; | |||
@@ -517,7 +517,7 @@ public class FieldGroup implements Serializable { | |||
* commits succeeded | |||
*/ | |||
private Map<Field<?>, InvalidValueException> commitFields() { | |||
Map<Field<?>, InvalidValueException> invalidValueExceptions = new HashMap<>(); | |||
Map<Field<?>, InvalidValueException> invalidValueExceptions = new HashMap<Field<?>, InvalidValueException>(); | |||
for (Field<?> f : fieldToPropertyId.keySet()) { | |||
try { | |||
@@ -1112,7 +1112,7 @@ public class FieldGroup implements Serializable { | |||
return ((FieldGroupInvalidValueException) getCause()) | |||
.getInvalidFields(); | |||
} | |||
return new HashMap<>(); | |||
return new HashMap<Field<?>, InvalidValueException>(); | |||
} | |||
/** | |||
@@ -1254,7 +1254,7 @@ public class FieldGroup implements Serializable { | |||
*/ | |||
protected static List<java.lang.reflect.Field> getFieldsInDeclareOrder( | |||
Class searchClass) { | |||
ArrayList<java.lang.reflect.Field> memberFieldInOrder = new ArrayList<>(); | |||
ArrayList<java.lang.reflect.Field> memberFieldInOrder = new ArrayList<java.lang.reflect.Field>(); | |||
while (searchClass != null) { | |||
for (java.lang.reflect.Field memberField : searchClass |
@@ -141,7 +141,7 @@ public class Sort implements Serializable { | |||
++count; | |||
} | |||
List<SortOrder> order = new ArrayList<>(count); | |||
List<SortOrder> order = new ArrayList<SortOrder>(count); | |||
s = this; | |||
do { |
@@ -144,7 +144,7 @@ public abstract class AbstractBeanContainer<IDTYPE, BEANTYPE> | |||
* Maps all item ids in the container (including filtered) to their | |||
* corresponding BeanItem. | |||
*/ | |||
private final Map<IDTYPE, BeanItem<BEANTYPE>> itemIdToItem = new HashMap<>(); | |||
private final Map<IDTYPE, BeanItem<BEANTYPE>> itemIdToItem = new HashMap<IDTYPE, BeanItem<BEANTYPE>>(); | |||
/** | |||
* The type of the beans in the container. | |||
@@ -196,7 +196,7 @@ public abstract class AbstractBeanContainer<IDTYPE, BEANTYPE> | |||
* @return created {@link BeanItem} or null if bean is null | |||
*/ | |||
protected BeanItem<BEANTYPE> createBeanItem(BEANTYPE bean) { | |||
return bean == null ? null : new BeanItem<>(bean, model); | |||
return bean == null ? null : new BeanItem<BEANTYPE>(bean, model); | |||
} | |||
/** | |||
@@ -891,7 +891,7 @@ public abstract class AbstractBeanContainer<IDTYPE, BEANTYPE> | |||
.getPropertyDescriptors((Class<Object>) propertyType); | |||
for (String subPropertyId : pds.keySet()) { | |||
String qualifiedPropertyId = propertyId + "." + subPropertyId; | |||
NestedPropertyDescriptor<BEANTYPE> pd = new NestedPropertyDescriptor<>( | |||
NestedPropertyDescriptor<BEANTYPE> pd = new NestedPropertyDescriptor<BEANTYPE>( | |||
qualifiedPropertyId, (Class<BEANTYPE>) type); | |||
model.put(qualifiedPropertyId, pd); | |||
model.remove(propertyId); |
@@ -120,7 +120,7 @@ public abstract class AbstractInMemoryContainer<ITEMIDTYPE, PROPERTYIDCLASS, ITE | |||
* Filters that are applied to the container to limit the items visible in | |||
* it | |||
*/ | |||
private Set<Filter> filters = new HashSet<>(); | |||
private Set<Filter> filters = new HashSet<Filter>(); | |||
/** | |||
* The item sorter which is used for sorting the container. | |||
@@ -671,7 +671,7 @@ public abstract class AbstractInMemoryContainer<ITEMIDTYPE, PROPERTYIDCLASS, ITE | |||
if (getFilters().isEmpty() || propertyId == null) { | |||
return Collections.emptyList(); | |||
} | |||
List<Filter> removedFilters = new LinkedList<>(); | |||
List<Filter> removedFilters = new LinkedList<Filter>(); | |||
for (Iterator<Filter> iterator = getFilters().iterator(); iterator | |||
.hasNext();) { | |||
Filter f = iterator.next(); | |||
@@ -760,7 +760,7 @@ public abstract class AbstractInMemoryContainer<ITEMIDTYPE, PROPERTYIDCLASS, ITE | |||
* to implement {@link Sortable#getSortableContainerPropertyIds()}. | |||
*/ | |||
protected Collection<?> getSortablePropertyIds() { | |||
LinkedList<Object> sortables = new LinkedList<>(); | |||
LinkedList<Object> sortables = new LinkedList<Object>(); | |||
for (Object propertyId : getContainerPropertyIds()) { | |||
Class<?> propertyType = getType(propertyId); | |||
if (Comparable.class.isAssignableFrom(propertyType) |
@@ -113,7 +113,7 @@ public abstract class AbstractProperty<T> implements Property<T>, | |||
public void addReadOnlyStatusChangeListener( | |||
Property.ReadOnlyStatusChangeListener listener) { | |||
if (readOnlyStatusChangeListeners == null) { | |||
readOnlyStatusChangeListeners = new LinkedList<>(); | |||
readOnlyStatusChangeListeners = new LinkedList<ReadOnlyStatusChangeListener>(); | |||
} | |||
readOnlyStatusChangeListeners.add(listener); | |||
} | |||
@@ -199,7 +199,7 @@ public abstract class AbstractProperty<T> implements Property<T>, | |||
@Override | |||
public void addValueChangeListener(ValueChangeListener listener) { | |||
if (valueChangeListeners == null) { | |||
valueChangeListeners = new LinkedList<>(); | |||
valueChangeListeners = new LinkedList<ValueChangeListener>(); | |||
} | |||
valueChangeListeners.add(listener); | |||
@@ -187,7 +187,7 @@ public class BeanItem<BT> extends PropertysetItem { | |||
*/ | |||
static <BT> LinkedHashMap<String, VaadinPropertyDescriptor<BT>> getPropertyDescriptors( | |||
final Class<BT> beanClass) { | |||
final LinkedHashMap<String, VaadinPropertyDescriptor<BT>> pdMap = new LinkedHashMap<>(); | |||
final LinkedHashMap<String, VaadinPropertyDescriptor<BT>> pdMap = new LinkedHashMap<String, VaadinPropertyDescriptor<BT>>(); | |||
// Try to introspect, if it fails, we just have an empty Item | |||
try { | |||
@@ -200,7 +200,7 @@ public class BeanItem<BT> extends PropertysetItem { | |||
final Method getMethod = pd.getReadMethod(); | |||
if ((getMethod != null) | |||
&& getMethod.getDeclaringClass() != Object.class) { | |||
VaadinPropertyDescriptor<BT> vaadinPropertyDescriptor = new MethodPropertyDescriptor<>( | |||
VaadinPropertyDescriptor<BT> vaadinPropertyDescriptor = new MethodPropertyDescriptor<BT>( | |||
pd.getName(), pd.getPropertyType(), | |||
pd.getReadMethod(), pd.getWriteMethod()); | |||
pdMap.put(pd.getName(), vaadinPropertyDescriptor); | |||
@@ -224,7 +224,7 @@ public class BeanItem<BT> extends PropertysetItem { | |||
* not specified | |||
*/ | |||
public void expandProperty(String propertyId, String... subPropertyIds) { | |||
Set<String> subPropertySet = new HashSet<>( | |||
Set<String> subPropertySet = new HashSet<String>( | |||
Arrays.asList(subPropertyIds)); | |||
if (0 == subPropertyIds.length) { | |||
@@ -253,7 +253,7 @@ public class BeanItem<BT> extends PropertysetItem { | |||
*/ | |||
public void addNestedProperty(String nestedPropertyId) { | |||
addItemProperty(nestedPropertyId, | |||
new NestedMethodProperty<>(getBean(), nestedPropertyId)); | |||
new NestedMethodProperty<BT>(getBean(), nestedPropertyId)); | |||
} | |||
/** | |||
@@ -275,7 +275,7 @@ public class BeanItem<BT> extends PropertysetItem { | |||
* <p> | |||
* Changing the bean will fire value change events for all properties of | |||
* type {@link MethodProperty} or {@link NestedMethodProperty}. | |||
* | |||
* | |||
* @param bean | |||
* The new bean to use for this item, not <code>null</code> | |||
*/ |
@@ -119,10 +119,10 @@ public class ContainerHierarchicalWrapper implements Container.Hierarchical, | |||
// Create initial order if needed | |||
if (!hierarchical) { | |||
noChildrenAllowed = new HashSet<>(); | |||
parent = new Hashtable<>(); | |||
children = new Hashtable<>(); | |||
roots = new LinkedHashSet<>(container.getItemIds()); | |||
noChildrenAllowed = new HashSet<Object>(); | |||
parent = new Hashtable<Object, Object>(); | |||
children = new Hashtable<Object, LinkedList<Object>>(); | |||
roots = new LinkedHashSet<Object>(container.getItemIds()); | |||
} | |||
updateHierarchicalWrapper(); | |||
@@ -142,10 +142,10 @@ public class ContainerHierarchicalWrapper implements Container.Hierarchical, | |||
// Recreate hierarchy and data structures if missing | |||
if (noChildrenAllowed == null || parent == null || children == null | |||
|| roots == null) { | |||
noChildrenAllowed = new HashSet<>(); | |||
parent = new Hashtable<>(); | |||
children = new Hashtable<>(); | |||
roots = new LinkedHashSet<>(container.getItemIds()); | |||
noChildrenAllowed = new HashSet<Object>(); | |||
parent = new Hashtable<Object, Object>(); | |||
children = new Hashtable<Object, LinkedList<Object>>(); | |||
roots = new LinkedHashSet<Object>(container.getItemIds()); | |||
} | |||
// Check that the hierarchy is up-to-date | |||
@@ -158,7 +158,7 @@ public class ContainerHierarchicalWrapper implements Container.Hierarchical, | |||
itemIds); | |||
// Calculate the set of all items in the hierarchy | |||
final HashSet<Object> s = new HashSet<>(); | |||
final HashSet<Object> s = new HashSet<Object>(); | |||
s.addAll(parent.keySet()); | |||
s.addAll(children.keySet()); | |||
s.addAll(roots); | |||
@@ -183,7 +183,7 @@ public class ContainerHierarchicalWrapper implements Container.Hierarchical, | |||
Object[] array = roots.toArray(); | |||
Arrays.sort(array, basedOnOrderFromWrappedContainer); | |||
roots = new LinkedHashSet<>(); | |||
roots = new LinkedHashSet<Object>(); | |||
for (int i = 0; i < array.length; i++) { | |||
roots.add(array[i]); | |||
} | |||
@@ -476,7 +476,7 @@ public class ContainerHierarchicalWrapper implements Container.Hierarchical, | |||
parent.put(itemId, newParentId); | |||
LinkedList<Object> pcl = children.get(newParentId); | |||
if (pcl == null) { | |||
pcl = new LinkedList<>(); | |||
pcl = new LinkedList<Object>(); | |||
children.put(newParentId, pcl); | |||
} | |||
pcl.add(itemId); |
@@ -216,12 +216,12 @@ public class ContainerOrderedWrapper implements Container.Ordered, | |||
if (next == null || first == null || last == null || prev == null) { | |||
first = null; | |||
last = null; | |||
next = new Hashtable<>(); | |||
prev = new Hashtable<>(); | |||
next = new Hashtable<Object, Object>(); | |||
prev = new Hashtable<Object, Object>(); | |||
} | |||
// Filter out all the missing items | |||
final LinkedList<?> l = new LinkedList<>(next.keySet()); | |||
final LinkedList<?> l = new LinkedList<Object>(next.keySet()); | |||
for (final Iterator<?> i = l.iterator(); i.hasNext();) { | |||
final Object id = i.next(); | |||
if (!container.containsId(id)) { | |||
@@ -470,9 +470,9 @@ public class ContainerOrderedWrapper implements Container.Ordered, | |||
if (ordered) { | |||
return ((Container.Ordered) container).getItemIds(); | |||
} else if (first == null) { | |||
return new ArrayList<>(); | |||
return new ArrayList<Object>(); | |||
} else { | |||
List<Object> itemIds = new ArrayList<>(); | |||
List<Object> itemIds = new ArrayList<Object>(); | |||
itemIds.add(first); | |||
Object current = first; | |||
while (next.containsKey(current)) { |
@@ -166,8 +166,8 @@ public class DefaultItemSorter implements ItemSorter { | |||
this.container = container; | |||
// Removes any non-sortable property ids | |||
final List<Object> ids = new ArrayList<>(); | |||
final List<Boolean> orders = new ArrayList<>(); | |||
final List<Object> ids = new ArrayList<Object>(); | |||
final List<Boolean> orders = new ArrayList<Boolean>(); | |||
final Collection<?> sortable = container | |||
.getSortableContainerPropertyIds(); | |||
for (int i = 0; i < propertyId.length; i++) { |
@@ -81,7 +81,7 @@ public class FilesystemContainer implements Container.Hierarchical { | |||
static { | |||
FILE_PROPERTIES = new ArrayList<>(); | |||
FILE_PROPERTIES = new ArrayList<String>(); | |||
FILE_PROPERTIES.add(PROPERTY_NAME); | |||
FILE_PROPERTIES.add(PROPERTY_ICON); | |||
FILE_PROPERTIES.add(PROPERTY_SIZE); | |||
@@ -441,7 +441,7 @@ public class FilesystemContainer implements Container.Hierarchical { | |||
public Collection<File> getItemIds() { | |||
if (recursive) { | |||
final Collection<File> col = new ArrayList<>(); | |||
final Collection<File> col = new ArrayList<File>(); | |||
for (int i = 0; i < roots.length; i++) { | |||
addItemIds(col, roots[i]); | |||
} |
@@ -71,7 +71,7 @@ public class GeneratedPropertyContainer extends AbstractContainer | |||
private Filterable filterableContainer = null; | |||
/* Removed properties which are hidden but not actually removed */ | |||
private final Set<Object> removedProperties = new HashSet<>(); | |||
private final Set<Object> removedProperties = new HashSet<Object>(); | |||
/** | |||
* Property implementation for generated properties | |||
@@ -150,7 +150,7 @@ public class GeneratedPropertyContainer extends AbstractContainer | |||
@Override | |||
public Collection<?> getItemPropertyIds() { | |||
Set<Object> wrappedProperties = new LinkedHashSet<>( | |||
Set<Object> wrappedProperties = new LinkedHashSet<Object>( | |||
wrappedItem.getItemPropertyIds()); | |||
wrappedProperties.removeAll(removedProperties); | |||
wrappedProperties.addAll(propertyGenerators.keySet()); | |||
@@ -292,14 +292,14 @@ public class GeneratedPropertyContainer extends AbstractContainer | |||
@Deprecated | |||
public GeneratedPropertyContainer(Container.Indexed container) { | |||
wrappedContainer = container; | |||
propertyGenerators = new HashMap<>(); | |||
propertyGenerators = new HashMap<Object, PropertyValueGenerator<?>>(); | |||
if (wrappedContainer instanceof Sortable) { | |||
sortableContainer = (Sortable) wrappedContainer; | |||
} | |||
if (wrappedContainer instanceof Filterable) { | |||
activeFilters = new HashMap<>(); | |||
activeFilters = new HashMap<Filter, List<Filter>>(); | |||
filterableContainer = (Filterable) wrappedContainer; | |||
} else { | |||
activeFilters = null; | |||
@@ -383,7 +383,7 @@ public class GeneratedPropertyContainer extends AbstractContainer | |||
private <T> Property<T> createProperty(final Item item, | |||
final Object propertyId, final Object itemId, | |||
final PropertyValueGenerator<T> generator) { | |||
return new GeneratedProperty<>(item, propertyId, itemId, generator); | |||
return new GeneratedProperty<T>(item, propertyId, itemId, generator); | |||
} | |||
/* Listener functionality */ | |||
@@ -440,7 +440,7 @@ public class GeneratedPropertyContainer extends AbstractContainer | |||
"Wrapped container is not filterable"); | |||
} | |||
List<Filter> addedFilters = new ArrayList<>(); | |||
List<Filter> addedFilters = new ArrayList<Filter>(); | |||
for (Entry<?, PropertyValueGenerator<?>> entry : propertyGenerators | |||
.entrySet()) { | |||
Object property = entry.getKey(); | |||
@@ -511,8 +511,8 @@ public class GeneratedPropertyContainer extends AbstractContainer | |||
return; | |||
} | |||
List<Object> actualSortProperties = new ArrayList<>(); | |||
List<Boolean> actualSortDirections = new ArrayList<>(); | |||
List<Object> actualSortProperties = new ArrayList<Object>(); | |||
List<Boolean> actualSortDirections = new ArrayList<Boolean>(); | |||
for (int i = 0; i < propertyId.length; ++i) { | |||
Object property = propertyId[i]; | |||
@@ -555,7 +555,7 @@ public class GeneratedPropertyContainer extends AbstractContainer | |||
return Collections.emptySet(); | |||
} | |||
Set<Object> sortablePropertySet = new HashSet<>( | |||
Set<Object> sortablePropertySet = new HashSet<Object>( | |||
sortableContainer.getSortableContainerPropertyIds()); | |||
for (Entry<?, PropertyValueGenerator<?>> entry : propertyGenerators | |||
.entrySet()) { | |||
@@ -632,7 +632,7 @@ public class GeneratedPropertyContainer extends AbstractContainer | |||
*/ | |||
@Override | |||
public Collection<?> getContainerPropertyIds() { | |||
Set<Object> wrappedProperties = new LinkedHashSet<>( | |||
Set<Object> wrappedProperties = new LinkedHashSet<Object>( | |||
wrappedContainer.getContainerPropertyIds()); | |||
wrappedProperties.removeAll(removedProperties); | |||
wrappedProperties.addAll(propertyGenerators.keySet()); |
@@ -44,12 +44,12 @@ public class HierarchicalContainer extends IndexedContainer | |||
/** | |||
* Set of IDs of those contained Items that can't have children. | |||
*/ | |||
private final HashSet<Object> noChildrenAllowed = new HashSet<>(); | |||
private final HashSet<Object> noChildrenAllowed = new HashSet<Object>(); | |||
/** | |||
* Mapping from Item ID to parent Item ID. | |||
*/ | |||
private final HashMap<Object, Object> parent = new HashMap<>(); | |||
private final HashMap<Object, Object> parent = new HashMap<Object, Object>(); | |||
/** | |||
* Mapping from Item ID to parent Item ID for items included in the filtered | |||
@@ -60,7 +60,7 @@ public class HierarchicalContainer extends IndexedContainer | |||
/** | |||
* Mapping from Item ID to a list of child IDs. | |||
*/ | |||
private final HashMap<Object, LinkedList<Object>> children = new HashMap<>(); | |||
private final HashMap<Object, LinkedList<Object>> children = new HashMap<Object, LinkedList<Object>>(); | |||
/** | |||
* Mapping from Item ID to a list of child IDs when filtered | |||
@@ -70,7 +70,7 @@ public class HierarchicalContainer extends IndexedContainer | |||
/** | |||
* List that contains all root elements of the container. | |||
*/ | |||
private final LinkedList<Object> roots = new LinkedList<>(); | |||
private final LinkedList<Object> roots = new LinkedList<Object>(); | |||
/** | |||
* List that contains all filtered root elements of the container. | |||
@@ -325,7 +325,7 @@ public class HierarchicalContainer extends IndexedContainer | |||
if (pcl == null) { | |||
// Create an empty list for holding children if one were not | |||
// previously created | |||
pcl = new LinkedList<>(); | |||
pcl = new LinkedList<Object>(); | |||
children.put(newParentId, pcl); | |||
} | |||
pcl.add(itemId); | |||
@@ -712,14 +712,14 @@ public class HierarchicalContainer extends IndexedContainer | |||
} | |||
// Reset data structures | |||
filteredRoots = new LinkedList<>(); | |||
filteredChildren = new HashMap<>(); | |||
filteredParent = new HashMap<>(); | |||
filteredRoots = new LinkedList<Object>(); | |||
filteredChildren = new HashMap<Object, LinkedList<Object>>(); | |||
filteredParent = new HashMap<Object, Object>(); | |||
if (includeParentsWhenFiltering) { | |||
// Filter so that parents for items that match the filter are also | |||
// included | |||
HashSet<Object> includedItems = new HashSet<>(); | |||
HashSet<Object> includedItems = new HashSet<Object>(); | |||
for (Object rootId : roots) { | |||
if (filterIncludingParents(rootId, includedItems)) { | |||
filteredRoots.add(rootId); | |||
@@ -741,7 +741,7 @@ public class HierarchicalContainer extends IndexedContainer | |||
// match | |||
super.doFilterContainer(hasFilters); | |||
LinkedHashSet<Object> filteredItemIds = new LinkedHashSet<>( | |||
LinkedHashSet<Object> filteredItemIds = new LinkedHashSet<Object>( | |||
getItemIds()); | |||
for (Object itemId : filteredItemIds) { | |||
@@ -773,7 +773,7 @@ public class HierarchicalContainer extends IndexedContainer | |||
LinkedList<Object> parentToChildrenList = filteredChildren | |||
.get(parentItemId); | |||
if (parentToChildrenList == null) { | |||
parentToChildrenList = new LinkedList<>(); | |||
parentToChildrenList = new LinkedList<Object>(); | |||
filteredChildren.put(parentItemId, parentToChildrenList); | |||
} | |||
filteredParent.put(childItemId, parentItemId); |
@@ -71,23 +71,23 @@ public class IndexedContainer | |||
/** | |||
* Linked list of ordered Property IDs. | |||
*/ | |||
private ArrayList<Object> propertyIds = new ArrayList<>(); | |||
private ArrayList<Object> propertyIds = new ArrayList<Object>(); | |||
/** | |||
* Property ID to type mapping. | |||
*/ | |||
private Hashtable<Object, Class<?>> types = new Hashtable<>(); | |||
private Hashtable<Object, Class<?>> types = new Hashtable<Object, Class<?>>(); | |||
/** | |||
* Hash of Items, where each Item is implemented as a mapping from Property | |||
* ID to Property value. | |||
*/ | |||
private Hashtable<Object, Map<Object, Object>> items = new Hashtable<>(); | |||
private Hashtable<Object, Map<Object, Object>> items = new Hashtable<Object, Map<Object, Object>>(); | |||
/** | |||
* Set of properties that are read-only. | |||
*/ | |||
private HashSet<Property<?>> readOnlyProperties = new HashSet<>(); | |||
private HashSet<Property<?>> readOnlyProperties = new HashSet<Property<?>>(); | |||
/** | |||
* List of all Property value change event listeners listening all the | |||
@@ -192,7 +192,7 @@ public class IndexedContainer | |||
} | |||
// store for next rows | |||
if (defaultPropertyValues == null) { | |||
defaultPropertyValues = new HashMap<>(); | |||
defaultPropertyValues = new HashMap<Object, Object>(); | |||
} | |||
defaultPropertyValues.put(propertyId, defaultValue); | |||
} | |||
@@ -386,7 +386,7 @@ public class IndexedContainer | |||
@Override | |||
protected void registerNewItem(int index, Object newItemId, Item item) { | |||
Hashtable<Object, Object> t = new Hashtable<>(); | |||
Hashtable<Object, Object> t = new Hashtable<Object, Object>(); | |||
items.put(newItemId, t); | |||
addDefaultValues(t); | |||
} | |||
@@ -479,7 +479,7 @@ public class IndexedContainer | |||
@Override | |||
public void addValueChangeListener(Property.ValueChangeListener listener) { | |||
if (propertyValueChangeListeners == null) { | |||
propertyValueChangeListeners = new LinkedList<>(); | |||
propertyValueChangeListeners = new LinkedList<Property.ValueChangeListener>(); | |||
} | |||
propertyValueChangeListeners.add(listener); | |||
} | |||
@@ -590,19 +590,19 @@ public class IndexedContainer | |||
Object itemId, Property.ValueChangeListener listener) { | |||
if (listener != null) { | |||
if (singlePropertyValueChangeListeners == null) { | |||
singlePropertyValueChangeListeners = new Hashtable<>(); | |||
singlePropertyValueChangeListeners = new Hashtable<Object, Map<Object, List<Property.ValueChangeListener>>>(); | |||
} | |||
Map<Object, List<Property.ValueChangeListener>> propertySetToListenerListMap = singlePropertyValueChangeListeners | |||
.get(propertyId); | |||
if (propertySetToListenerListMap == null) { | |||
propertySetToListenerListMap = new Hashtable<>(); | |||
propertySetToListenerListMap = new Hashtable<Object, List<Property.ValueChangeListener>>(); | |||
singlePropertyValueChangeListeners.put(propertyId, | |||
propertySetToListenerListMap); | |||
} | |||
List<Property.ValueChangeListener> listenerList = propertySetToListenerListMap | |||
.get(itemId); | |||
if (listenerList == null) { | |||
listenerList = new LinkedList<>(); | |||
listenerList = new LinkedList<Property.ValueChangeListener>(); | |||
propertySetToListenerListMap.put(itemId, listenerList); | |||
} | |||
listenerList.add(listener); | |||
@@ -982,11 +982,15 @@ public class IndexedContainer | |||
? (ListSet<Object>) ((ListSet<Object>) getAllItemIds()).clone() | |||
: null); | |||
nc.setItemSetChangeListeners(getItemSetChangeListeners() != null | |||
? new LinkedList<>(getItemSetChangeListeners()) : null); | |||
? new LinkedList<ItemSetChangeListener>( | |||
getItemSetChangeListeners()) | |||
: null); | |||
nc.propertyIds = propertyIds != null | |||
? (ArrayList<Object>) propertyIds.clone() : null; | |||
nc.setPropertySetChangeListeners(getPropertySetChangeListeners() != null | |||
? new LinkedList<>(getPropertySetChangeListeners()) : null); | |||
? new LinkedList<PropertySetChangeListener>( | |||
getPropertySetChangeListeners()) | |||
: null); | |||
nc.propertyValueChangeListeners = propertyValueChangeListeners != null | |||
? (LinkedList<Property.ValueChangeListener>) propertyValueChangeListeners | |||
.clone() | |||
@@ -1012,7 +1016,7 @@ public class IndexedContainer | |||
if (items == null) { | |||
nc.items = null; | |||
} else { | |||
nc.items = new Hashtable<>(); | |||
nc.items = new Hashtable<Object, Map<Object, Object>>(); | |||
for (final Iterator<?> i = items.keySet().iterator(); i | |||
.hasNext();) { | |||
final Object id = i.next(); |
@@ -40,22 +40,22 @@ public class ListSet<E> extends ArrayList<E> { | |||
* Contains a map from an element to the number of duplicates it has. Used | |||
* to temporarily allow duplicates in the list. | |||
*/ | |||
private HashMap<E, Integer> duplicates = new HashMap<>(); | |||
private HashMap<E, Integer> duplicates = new HashMap<E, Integer>(); | |||
public ListSet() { | |||
super(); | |||
itemSet = new HashSet<>(); | |||
itemSet = new HashSet<E>(); | |||
} | |||
public ListSet(Collection<? extends E> c) { | |||
super(c); | |||
itemSet = new HashSet<>(c.size()); | |||
itemSet = new HashSet<E>(c.size()); | |||
itemSet.addAll(c); | |||
} | |||
public ListSet(int initialCapacity) { | |||
super(initialCapacity); | |||
itemSet = new HashSet<>(initialCapacity); | |||
itemSet = new HashSet<E>(initialCapacity); | |||
} | |||
// Delegate contains operations to the set | |||
@@ -185,7 +185,7 @@ public class ListSet<E> extends ArrayList<E> { | |||
@Override | |||
protected void removeRange(int fromIndex, int toIndex) { | |||
HashSet<E> toRemove = new HashSet<>(); | |||
HashSet<E> toRemove = new HashSet<E>(); | |||
for (int idx = fromIndex; idx < toIndex; idx++) { | |||
toRemove.add(get(idx)); | |||
} | |||
@@ -270,7 +270,7 @@ public class ListSet<E> extends ArrayList<E> { | |||
@Override | |||
public Object clone() { | |||
ListSet<E> v = (ListSet<E>) super.clone(); | |||
v.itemSet = new HashSet<>(itemSet); | |||
v.itemSet = new HashSet<E>(itemSet); | |||
return v; | |||
} | |||
@@ -125,7 +125,7 @@ public class NestedMethodProperty<T> extends AbstractProperty<T> { | |||
private void initialize(Class<?> beanClass, String propertyName) | |||
throws IllegalArgumentException { | |||
List<Method> getMethods = new ArrayList<>(); | |||
List<Method> getMethods = new ArrayList<Method>(); | |||
String lastSimplePropertyName = propertyName; | |||
Class<?> lastClass = beanClass; | |||
@@ -270,7 +270,7 @@ public class NestedMethodProperty<T> extends AbstractProperty<T> { | |||
/** | |||
* The instance used by this property | |||
* | |||
* | |||
* @return the instance used for fetching the property value | |||
*/ | |||
public Object getInstance() { | |||
@@ -284,7 +284,7 @@ public class NestedMethodProperty<T> extends AbstractProperty<T> { | |||
* <p> | |||
* To be consistent with {@link #setValue(Object)}, this method will fire a | |||
* value change event even if the value stays the same | |||
* | |||
* | |||
* @param instance | |||
* the instance to use | |||
*/ |
@@ -50,7 +50,7 @@ public class NestedPropertyDescriptor<BT> | |||
public NestedPropertyDescriptor(String name, Class<BT> beanType) | |||
throws IllegalArgumentException { | |||
this.name = name; | |||
NestedMethodProperty<?> property = new NestedMethodProperty<>( | |||
NestedMethodProperty<?> property = new NestedMethodProperty<BT>( | |||
beanType, name); | |||
this.propertyType = property.getType(); | |||
} | |||
@@ -67,7 +67,7 @@ public class NestedPropertyDescriptor<BT> | |||
@Override | |||
public Property<?> createProperty(BT bean) { | |||
return new NestedMethodProperty<>(bean, name); | |||
return new NestedMethodProperty<BT>(bean, name); | |||
} | |||
} |
@@ -45,12 +45,12 @@ public class PropertysetItem | |||
/** | |||
* Mapping from property id to property. | |||
*/ | |||
private HashMap<Object, Property<?>> map = new HashMap<>(); | |||
private HashMap<Object, Property<?>> map = new HashMap<Object, Property<?>>(); | |||
/** | |||
* List of all property ids to maintain the order. | |||
*/ | |||
private LinkedList<Object> list = new LinkedList<>(); | |||
private LinkedList<Object> list = new LinkedList<Object>(); | |||
/** | |||
* List of property set modification listeners. | |||
@@ -205,7 +205,7 @@ public class PropertysetItem | |||
public void addPropertySetChangeListener( | |||
Item.PropertySetChangeListener listener) { | |||
if (propertySetChangeListeners == null) { | |||
propertySetChangeListeners = new LinkedList<>(); | |||
propertySetChangeListeners = new LinkedList<Item.PropertySetChangeListener>(); | |||
} | |||
propertySetChangeListeners.add(listener); | |||
} |
@@ -58,7 +58,7 @@ public class DefaultConverterFactory implements ConverterFactory { | |||
if (reverseConverter != null) { | |||
log.finest(getClass().getName() + " created a reverse " | |||
+ reverseConverter.getClass()); | |||
return new ReverseConverter<>(reverseConverter); | |||
return new ReverseConverter<PRESENTATION, MODEL>(reverseConverter); | |||
} | |||
log.finest(getClass().getName() + " could not find a converter for " |
@@ -35,8 +35,8 @@ class CacheFlushNotifier implements Serializable { | |||
* SQLContainer instance reference list and dead reference queue. Used for | |||
* the cache flush notification feature. | |||
*/ | |||
private static List<WeakReference<SQLContainer>> allInstances = new ArrayList<>(); | |||
private static ReferenceQueue<SQLContainer> deadInstances = new ReferenceQueue<>(); | |||
private static List<WeakReference<SQLContainer>> allInstances = new ArrayList<WeakReference<SQLContainer>>(); | |||
private static ReferenceQueue<SQLContainer> deadInstances = new ReferenceQueue<SQLContainer>(); | |||
/** | |||
* Adds the given SQLContainer to the cache flush notification receiver list | |||
@@ -47,7 +47,7 @@ class CacheFlushNotifier implements Serializable { | |||
public static void addInstance(SQLContainer c) { | |||
removeDeadReferences(); | |||
if (c != null) { | |||
allInstances.add(new WeakReference<>(c, deadInstances)); | |||
allInstances.add(new WeakReference<SQLContainer>(c, deadInstances)); | |||
} | |||
} | |||
@@ -75,7 +75,7 @@ public final class RowItem implements Item { | |||
@Override | |||
public Collection<?> getItemPropertyIds() { | |||
Collection<String> ids = new ArrayList<>(properties.size()); | |||
Collection<String> ids = new ArrayList<String>(properties.size()); | |||
for (ColumnProperty cp : properties) { | |||
ids.add(cp.getPropertyId()); | |||
} |
@@ -66,20 +66,20 @@ public class SQLContainer implements Container, Container.Filterable, | |||
private int cacheOverlap = pageLength; | |||
/** Item and index caches */ | |||
private final Map<Integer, RowId> itemIndexes = new HashMap<>(); | |||
private final CacheMap<RowId, RowItem> cachedItems = new CacheMap<>(); | |||
private final Map<Integer, RowId> itemIndexes = new HashMap<Integer, RowId>(); | |||
private final CacheMap<RowId, RowItem> cachedItems = new CacheMap<RowId, RowItem>(); | |||
/** Container properties = column names, data types and statuses */ | |||
private final List<String> propertyIds = new ArrayList<>(); | |||
private final Map<String, Class<?>> propertyTypes = new HashMap<>(); | |||
private final Map<String, Boolean> propertyReadOnly = new HashMap<>(); | |||
private final Map<String, Boolean> propertyPersistable = new HashMap<>(); | |||
private final Map<String, Boolean> propertyNullable = new HashMap<>(); | |||
private final Map<String, Boolean> propertyPrimaryKey = new HashMap<>(); | |||
private final List<String> propertyIds = new ArrayList<String>(); | |||
private final Map<String, Class<?>> propertyTypes = new HashMap<String, Class<?>>(); | |||
private final Map<String, Boolean> propertyReadOnly = new HashMap<String, Boolean>(); | |||
private final Map<String, Boolean> propertyPersistable = new HashMap<String, Boolean>(); | |||
private final Map<String, Boolean> propertyNullable = new HashMap<String, Boolean>(); | |||
private final Map<String, Boolean> propertyPrimaryKey = new HashMap<String, Boolean>(); | |||
/** Filters (WHERE) and sorters (ORDER BY) */ | |||
private final List<Filter> filters = new ArrayList<>(); | |||
private final List<OrderBy> sorters = new ArrayList<>(); | |||
private final List<Filter> filters = new ArrayList<Filter>(); | |||
private final List<OrderBy> sorters = new ArrayList<OrderBy>(); | |||
/** | |||
* Total number of items available in the data source using the current | |||
@@ -104,12 +104,12 @@ public class SQLContainer implements Container, Container.Filterable, | |||
/** | |||
* Temporary storage for modified items and items to be removed and added | |||
*/ | |||
private final Map<RowId, RowItem> removedItems = new HashMap<>(); | |||
private final List<RowItem> addedItems = new ArrayList<>(); | |||
private final List<RowItem> modifiedItems = new ArrayList<>(); | |||
private final Map<RowId, RowItem> removedItems = new HashMap<RowId, RowItem>(); | |||
private final List<RowItem> addedItems = new ArrayList<RowItem>(); | |||
private final List<RowItem> modifiedItems = new ArrayList<RowItem>(); | |||
/** List of references to other SQLContainers */ | |||
private final Map<SQLContainer, Reference> references = new HashMap<>(); | |||
private final Map<SQLContainer, Reference> references = new HashMap<SQLContainer, Reference>(); | |||
/** Cache flush notification system enabled. Disabled by default. */ | |||
private boolean notificationsEnabled; | |||
@@ -157,7 +157,7 @@ public class SQLContainer implements Container, Container.Filterable, | |||
.size()]; | |||
RowId itemId = new TemporaryRowId(emptyKey); | |||
// Create new empty column properties for the row item. | |||
List<ColumnProperty> itemProperties = new ArrayList<>(); | |||
List<ColumnProperty> itemProperties = new ArrayList<ColumnProperty>(); | |||
for (String propertyId : propertyIds) { | |||
/* Default settings for new item properties. */ | |||
ColumnProperty cp = new ColumnProperty(propertyId, | |||
@@ -307,7 +307,7 @@ public class SQLContainer implements Container, Container.Filterable, | |||
@Override | |||
public Collection<?> getItemIds() { | |||
updateCount(); | |||
ArrayList<RowId> ids = new ArrayList<>(); | |||
ArrayList<RowId> ids = new ArrayList<RowId>(); | |||
ResultSet rs = null; | |||
try { | |||
// Load ALL rows :( | |||
@@ -536,7 +536,7 @@ public class SQLContainer implements Container, Container.Filterable, | |||
* {@inheritDoc} | |||
*/ | |||
public void removeContainerFilters(Object propertyId) { | |||
ArrayList<Filter> toRemove = new ArrayList<>(); | |||
ArrayList<Filter> toRemove = new ArrayList<Filter>(); | |||
for (Filter f : filters) { | |||
if (f.appliesToProperty(propertyId)) { | |||
toRemove.add(f); | |||
@@ -1200,7 +1200,7 @@ public class SQLContainer implements Container, Container.Filterable, | |||
setPageLengthInternal(size); | |||
} | |||
while (rs.next()) { | |||
List<ColumnProperty> itemProperties = new ArrayList<>(); | |||
List<ColumnProperty> itemProperties = new ArrayList<ColumnProperty>(); | |||
/* Generate row itemId based on primary key(s) */ | |||
Object[] itemId = new Object[pKeys.size()]; | |||
for (int i = 0; i < pKeys.size(); i++) { | |||
@@ -1212,7 +1212,8 @@ public class SQLContainer implements Container, Container.Filterable, | |||
} else { | |||
id = new RowId(itemId); | |||
} | |||
List<String> propertiesToAdd = new ArrayList<>(propertyIds); | |||
List<String> propertiesToAdd = new ArrayList<String>( | |||
propertyIds); | |||
if (!removedItems.containsKey(id)) { | |||
for (int i = 1; i <= rsmd.getColumnCount(); i++) { | |||
if (!isColumnIdentifierValid(rsmd.getColumnLabel(i))) { | |||
@@ -1315,7 +1316,7 @@ public class SQLContainer implements Container, Container.Filterable, | |||
} | |||
private List<RowItem> getFilteredAddedItems() { | |||
ArrayList<RowItem> filtered = new ArrayList<>(addedItems); | |||
ArrayList<RowItem> filtered = new ArrayList<RowItem>(addedItems); | |||
if (filters != null && !filters.isEmpty()) { | |||
for (RowItem item : addedItems) { | |||
if (!itemPassesFilters(item)) { | |||
@@ -1418,7 +1419,7 @@ public class SQLContainer implements Container, Container.Filterable, | |||
public void addItemSetChangeListener( | |||
Container.ItemSetChangeListener listener) { | |||
if (itemSetChangeListeners == null) { | |||
itemSetChangeListeners = new LinkedList<>(); | |||
itemSetChangeListeners = new LinkedList<ItemSetChangeListener>(); | |||
} | |||
itemSetChangeListeners.add(listener); | |||
} |
@@ -86,8 +86,8 @@ public class SimpleJDBCConnectionPool implements JDBCConnectionPool { | |||
} | |||
private void initializeConnections() throws SQLException { | |||
availableConnections = new HashSet<>(initialConnections); | |||
reservedConnections = new HashSet<>(initialConnections); | |||
availableConnections = new HashSet<Connection>(initialConnections); | |||
reservedConnections = new HashSet<Connection>(initialConnections); | |||
for (int i = 0; i < initialConnections; i++) { | |||
availableConnections.add(createConnection()); | |||
} |
@@ -69,7 +69,7 @@ public class FreeformQuery extends AbstractTransactionalQuery | |||
JDBCConnectionPool connectionPool) { | |||
super(connectionPool); | |||
if (primaryKeyColumns == null) { | |||
primaryKeyColumns = new ArrayList<>(); | |||
primaryKeyColumns = new ArrayList<String>(); | |||
} | |||
if (primaryKeyColumns.contains("")) { | |||
throw new IllegalArgumentException( |
@@ -80,7 +80,7 @@ public class TableQuery extends AbstractTransactionalQuery | |||
/** Row ID change listeners */ | |||
private LinkedList<RowIdChangeListener> rowIdChangeListeners; | |||
/** Row ID change events, stored until commit() is called */ | |||
private final List<RowIdChangeEvent> bufferedEvents = new ArrayList<>(); | |||
private final List<RowIdChangeEvent> bufferedEvents = new ArrayList<RowIdChangeEvent>(); | |||
/** Set to true to output generated SQL Queries to System.out */ | |||
private final boolean debug = false; | |||
@@ -230,7 +230,7 @@ public class TableQuery extends AbstractTransactionalQuery | |||
* first primary key column. | |||
*/ | |||
if (orderBys == null || orderBys.isEmpty()) { | |||
List<OrderBy> ob = new ArrayList<>(); | |||
List<OrderBy> ob = new ArrayList<OrderBy>(); | |||
for (int i = 0; i < primaryKeyColumns.size(); i++) { | |||
ob.add(new OrderBy(primaryKeyColumns.get(i), true)); | |||
} | |||
@@ -573,7 +573,7 @@ public class TableQuery extends AbstractTransactionalQuery | |||
} | |||
tables.close(); | |||
rs = dbmd.getPrimaryKeys(catalogName, schemaName, tableName); | |||
List<String> names = new ArrayList<>(); | |||
List<String> names = new ArrayList<String>(); | |||
while (rs.next()) { | |||
names.add(rs.getString("COLUMN_NAME")); | |||
} | |||
@@ -618,7 +618,7 @@ public class TableQuery extends AbstractTransactionalQuery | |||
private RowId getNewRowId(RowItem row, ResultSet genKeys) { | |||
try { | |||
/* Fetch primary key values and generate a map out of them. */ | |||
Map<String, Object> values = new HashMap<>(); | |||
Map<String, Object> values = new HashMap<String, Object>(); | |||
ResultSetMetaData rsmd = genKeys.getMetaData(); | |||
int colCount = rsmd.getColumnCount(); | |||
if (genKeys.next()) { | |||
@@ -627,7 +627,7 @@ public class TableQuery extends AbstractTransactionalQuery | |||
} | |||
} | |||
/* Generate new RowId */ | |||
List<Object> newRowId = new ArrayList<>(); | |||
List<Object> newRowId = new ArrayList<Object>(); | |||
if (values.size() == 1) { | |||
if (primaryKeyColumns.size() == 1) { | |||
newRowId.add(values.get(values.keySet().iterator().next())); | |||
@@ -677,7 +677,7 @@ public class TableQuery extends AbstractTransactionalQuery | |||
@Override | |||
public boolean containsRowWithKey(Object... keys) throws SQLException { | |||
ArrayList<Filter> filtersAndKeys = new ArrayList<>(); | |||
ArrayList<Filter> filtersAndKeys = new ArrayList<Filter>(); | |||
if (filters != null) { | |||
filtersAndKeys.addAll(filters); | |||
} | |||
@@ -757,7 +757,7 @@ public class TableQuery extends AbstractTransactionalQuery | |||
@Override | |||
public void addRowIdChangeListener(RowIdChangeListener listener) { | |||
if (rowIdChangeListeners == null) { | |||
rowIdChangeListeners = new LinkedList<>(); | |||
rowIdChangeListeners = new LinkedList<RowIdChangeListener>(); | |||
} | |||
rowIdChangeListeners.add(listener); | |||
} |
@@ -328,7 +328,7 @@ public class DefaultSQLGenerator implements SQLGenerator { | |||
} | |||
protected Map<String, Object> generateColumnToValueMap(RowItem item) { | |||
Map<String, Object> columnToValueMap = new HashMap<>(); | |||
Map<String, Object> columnToValueMap = new HashMap<String, Object>(); | |||
for (Object id : item.getItemPropertyIds()) { | |||
ColumnProperty cp = (ColumnProperty) item.getItemProperty(id); | |||
/* Prevent "rownum" usage as a column name if MSSQL or ORACLE */ | |||
@@ -345,7 +345,7 @@ public class DefaultSQLGenerator implements SQLGenerator { | |||
} | |||
protected Map<String, Object> generateRowIdentifiers(RowItem item) { | |||
Map<String, Object> rowIdentifiers = new HashMap<>(); | |||
Map<String, Object> rowIdentifiers = new HashMap<String, Object>(); | |||
for (Object id : item.getItemPropertyIds()) { | |||
ColumnProperty cp = (ColumnProperty) item.getItemProperty(id); | |||
/* Prevent "rownum" usage as a column name if MSSQL or ORACLE */ |
@@ -42,8 +42,8 @@ public class StatementHelper implements Serializable { | |||
private String queryString; | |||
private List<Object> parameters = new ArrayList<>(); | |||
private Map<Integer, Class<?>> dataTypes = new HashMap<>(); | |||
private List<Object> parameters = new ArrayList<Object>(); | |||
private Map<Integer, Class<?>> dataTypes = new HashMap<Integer, Class<?>>(); | |||
public StatementHelper() { | |||
} |
@@ -26,7 +26,7 @@ import com.vaadin.v7.data.util.sqlcontainer.query.generator.StatementHelper; | |||
@Deprecated | |||
public class QueryBuilder implements Serializable { | |||
private static ArrayList<FilterTranslator> filterTranslators = new ArrayList<>(); | |||
private static ArrayList<FilterTranslator> filterTranslators = new ArrayList<FilterTranslator>(); | |||
private static StringDecorator stringDecorator = new StringDecorator("\"", | |||
"\""); | |||
@@ -74,7 +74,7 @@ public class CompositeValidator implements Validator { | |||
/** | |||
* List of contained validators. | |||
*/ | |||
private final List<Validator> validators = new LinkedList<>(); | |||
private final List<Validator> validators = new LinkedList<Validator>(); | |||
/** | |||
* Construct a composite validator in <code>AND</code> mode without error | |||
@@ -240,7 +240,7 @@ public class CompositeValidator implements Validator { | |||
return null; | |||
} | |||
final HashSet<Validator> found = new HashSet<>(); | |||
final HashSet<Validator> found = new HashSet<Validator>(); | |||
for (Validator v : validators) { | |||
if (validatorType.isAssignableFrom(v.getClass())) { | |||
found.add(v); |
@@ -38,8 +38,8 @@ public class SelectionEvent extends EventObject { | |||
public SelectionEvent(Object source, Collection<Object> oldSelection, | |||
Collection<Object> newSelection) { | |||
super(source); | |||
this.oldSelection = new LinkedHashSet<>(oldSelection); | |||
this.newSelection = new LinkedHashSet<>(newSelection); | |||
this.oldSelection = new LinkedHashSet<Object>(oldSelection); | |||
this.newSelection = new LinkedHashSet<Object>(newSelection); | |||
} | |||
/** | |||
@@ -80,7 +80,7 @@ public class SelectionEvent extends EventObject { | |||
if (set2.isEmpty()) { | |||
return set1; | |||
} else { | |||
LinkedHashSet<T> set = new LinkedHashSet<>(set1); | |||
LinkedHashSet<T> set = new LinkedHashSet<T>(set1); | |||
set.removeAll(set2); | |||
return set; | |||
} |
@@ -72,9 +72,9 @@ public class RpcDataProviderExtension extends AbstractExtension { | |||
*/ | |||
private class ActiveItemHandler implements Serializable, DataGenerator { | |||
private final Map<Object, GridValueChangeListener> activeItemMap = new HashMap<>(); | |||
private final KeyMapper<Object> keyMapper = new KeyMapper<>(); | |||
private final Set<Object> droppedItems = new HashSet<>(); | |||
private final Map<Object, GridValueChangeListener> activeItemMap = new HashMap<Object, GridValueChangeListener>(); | |||
private final KeyMapper<Object> keyMapper = new KeyMapper<Object>(); | |||
private final Set<Object> droppedItems = new HashSet<Object>(); | |||
/** | |||
* Registers ValueChangeListeners for given item ids. | |||
@@ -118,7 +118,7 @@ public class RpcDataProviderExtension extends AbstractExtension { | |||
* @return collection of item ids | |||
*/ | |||
public Collection<Object> getActiveItemIds() { | |||
return new HashSet<>(activeItemMap.keySet()); | |||
return new HashSet<Object>(activeItemMap.keySet()); | |||
} | |||
/** | |||
@@ -127,7 +127,7 @@ public class RpcDataProviderExtension extends AbstractExtension { | |||
* @return collection of value change listeners | |||
*/ | |||
public Collection<GridValueChangeListener> getValueChangeListeners() { | |||
return new HashSet<>(activeItemMap.values()); | |||
return new HashSet<GridValueChangeListener>(activeItemMap.values()); | |||
} | |||
@Override | |||
@@ -245,7 +245,7 @@ public class RpcDataProviderExtension extends AbstractExtension { | |||
else { | |||
// Remove obsolete value change listeners. | |||
Set<Object> keySet = new HashSet<>( | |||
Set<Object> keySet = new HashSet<Object>( | |||
activeItemHandler.activeItemMap.keySet()); | |||
for (Object itemId : keySet) { | |||
activeItemHandler.removeListener(itemId); | |||
@@ -273,7 +273,7 @@ public class RpcDataProviderExtension extends AbstractExtension { | |||
/** Size possibly changed with a bare ItemSetChangeEvent */ | |||
private boolean bareItemSetTriggeredSizeChange = false; | |||
private final Set<DataGenerator> dataGenerators = new LinkedHashSet<>(); | |||
private final Set<DataGenerator> dataGenerators = new LinkedHashSet<DataGenerator>(); | |||
private final ActiveItemHandler activeItemHandler = new ActiveItemHandler(); | |||
@@ -458,7 +458,7 @@ public class RpcDataProviderExtension extends AbstractExtension { | |||
*/ | |||
private void insertRowData(final int index, final int count) { | |||
if (rowChanges == null) { | |||
rowChanges = new ArrayList<>(); | |||
rowChanges = new ArrayList<Runnable>(); | |||
} | |||
if (rowChanges.isEmpty()) { | |||
@@ -491,7 +491,7 @@ public class RpcDataProviderExtension extends AbstractExtension { | |||
*/ | |||
private void removeRowData(final int index, final int count) { | |||
if (rowChanges == null) { | |||
rowChanges = new ArrayList<>(); | |||
rowChanges = new ArrayList<Runnable>(); | |||
} | |||
if (rowChanges.isEmpty()) { | |||
@@ -516,7 +516,7 @@ public class RpcDataProviderExtension extends AbstractExtension { | |||
*/ | |||
public void updateRowData(Object itemId) { | |||
if (updatedItemIds == null) { | |||
updatedItemIds = new LinkedHashSet<>(); | |||
updatedItemIds = new LinkedHashSet<Object>(); | |||
} | |||
if (updatedItemIds.isEmpty()) { |
@@ -839,7 +839,7 @@ public abstract class AbstractField<T> extends AbstractLegacyComponent | |||
@Override | |||
public void addValidator(Validator validator) { | |||
if (validators == null) { | |||
validators = new LinkedList<>(); | |||
validators = new LinkedList<Validator>(); | |||
} | |||
validators.add(validator); | |||
markAsDirty(); | |||
@@ -962,7 +962,7 @@ public abstract class AbstractField<T> extends AbstractLegacyComponent | |||
} | |||
} | |||
List<InvalidValueException> validationExceptions = new ArrayList<>(); | |||
List<InvalidValueException> validationExceptions = new ArrayList<InvalidValueException>(); | |||
if (validators != null) { | |||
// Gets all the validation errors | |||
for (Validator v : validators) { |
@@ -233,17 +233,17 @@ public abstract class AbstractSelect extends AbstractField<Object> implements | |||
/** | |||
* Keymapper used to map key values. | |||
*/ | |||
protected KeyMapper<Object> itemIdMapper = new KeyMapper<>(); | |||
protected KeyMapper<Object> itemIdMapper = new KeyMapper<Object>(); | |||
/** | |||
* Item icons. | |||
*/ | |||
private final HashMap<Object, Resource> itemIcons = new HashMap<>(); | |||
private final HashMap<Object, Resource> itemIcons = new HashMap<Object, Resource>(); | |||
/** | |||
* Item captions. | |||
*/ | |||
private final HashMap<Object, String> itemCaptions = new HashMap<>(); | |||
private final HashMap<Object, String> itemCaptions = new HashMap<Object, String>(); | |||
/** | |||
* Item caption mode. | |||
@@ -471,7 +471,7 @@ public abstract class AbstractSelect extends AbstractField<Object> implements | |||
// TODO Optimize by adding repaintNotNeeded when applicable | |||
// Converts the key-array to id-set | |||
final LinkedList<Object> acceptedSelections = new LinkedList<>(); | |||
final LinkedList<Object> acceptedSelections = new LinkedList<Object>(); | |||
for (int i = 0; i < clientSideSelectedKeys.length; i++) { | |||
final Object id = itemIdMapper | |||
.get(clientSideSelectedKeys[i]); | |||
@@ -503,9 +503,9 @@ public abstract class AbstractSelect extends AbstractField<Object> implements | |||
@SuppressWarnings("unchecked") | |||
Set<Object> newsel = (Set<Object>) getValue(); | |||
if (newsel == null) { | |||
newsel = new LinkedHashSet<>(); | |||
newsel = new LinkedHashSet<Object>(); | |||
} else { | |||
newsel = new LinkedHashSet<>(newsel); | |||
newsel = new LinkedHashSet<Object>(newsel); | |||
} | |||
newsel.removeAll(visibleNotSelected); | |||
newsel.addAll(acceptedSelections); | |||
@@ -657,14 +657,14 @@ public abstract class AbstractSelect extends AbstractField<Object> implements | |||
// If the return value is not a set | |||
if (retValue == null) { | |||
return new HashSet<>(); | |||
return new HashSet<Object>(); | |||
} | |||
if (retValue instanceof Set) { | |||
return Collections.unmodifiableSet((Set<?>) retValue); | |||
} else if (retValue instanceof Collection) { | |||
return new HashSet<Object>((Collection<?>) retValue); | |||
} else { | |||
final Set<Object> s = new HashSet<>(); | |||
final Set<Object> s = new HashSet<Object>(); | |||
if (items.containsId(retValue)) { | |||
s.add(retValue); | |||
} | |||
@@ -722,7 +722,7 @@ public abstract class AbstractSelect extends AbstractField<Object> implements | |||
ConversionException, InvalidValueException { | |||
if (isMultiSelect()) { | |||
if (newFieldValue == null) { | |||
super.setValue(new LinkedHashSet<>(), repaintIsNotNeeded, | |||
super.setValue(new LinkedHashSet<Object>(), repaintIsNotNeeded, | |||
ignoreReadOnly); | |||
} else if (Collection.class | |||
.isAssignableFrom(newFieldValue.getClass())) { | |||
@@ -974,7 +974,7 @@ public abstract class AbstractSelect extends AbstractField<Object> implements | |||
if (isMultiSelect()) { | |||
Collection<Object> valueAsCollection = (Collection<Object>) value; | |||
List<Object> newSelection = new ArrayList<>( | |||
List<Object> newSelection = new ArrayList<Object>( | |||
valueAsCollection.size()); | |||
for (Object subValue : valueAsCollection) { | |||
if (containsId(subValue)) { | |||
@@ -1125,7 +1125,7 @@ public abstract class AbstractSelect extends AbstractField<Object> implements | |||
// Convert the value type | |||
if (multiSelect) { | |||
final Set<Object> s = new HashSet<>(); | |||
final Set<Object> s = new HashSet<Object>(); | |||
if (oldValue != null) { | |||
s.add(oldValue); | |||
} | |||
@@ -1530,7 +1530,7 @@ public abstract class AbstractSelect extends AbstractField<Object> implements | |||
setValue(itemId); | |||
} else if (!isSelected(itemId) && itemId != null | |||
&& items.containsId(itemId)) { | |||
final Set<Object> s = new HashSet<>((Set<?>) getValue()); | |||
final Set<Object> s = new HashSet<Object>((Set<?>) getValue()); | |||
s.add(itemId); | |||
setValue(s); | |||
} | |||
@@ -1548,7 +1548,7 @@ public abstract class AbstractSelect extends AbstractField<Object> implements | |||
public void unselect(Object itemId) { | |||
if (isSelected(itemId)) { | |||
if (isMultiSelect()) { | |||
final Set<Object> s = new HashSet<>((Set<?>) getValue()); | |||
final Set<Object> s = new HashSet<Object>((Set<?>) getValue()); | |||
s.remove(itemId); | |||
setValue(s); | |||
} else { | |||
@@ -1577,7 +1577,7 @@ public abstract class AbstractSelect extends AbstractField<Object> implements | |||
public void addPropertySetChangeListener( | |||
Container.PropertySetChangeListener listener) { | |||
if (propertySetEventListeners == null) { | |||
propertySetEventListeners = new LinkedHashSet<>(); | |||
propertySetEventListeners = new LinkedHashSet<PropertySetChangeListener>(); | |||
} | |||
propertySetEventListeners.add(listener); | |||
} | |||
@@ -1627,7 +1627,7 @@ public abstract class AbstractSelect extends AbstractField<Object> implements | |||
public void addItemSetChangeListener( | |||
Container.ItemSetChangeListener listener) { | |||
if (itemSetEventListeners == null) { | |||
itemSetEventListeners = new LinkedHashSet<>(); | |||
itemSetEventListeners = new LinkedHashSet<ItemSetChangeListener>(); | |||
} | |||
itemSetEventListeners.add(listener); | |||
} | |||
@@ -1914,7 +1914,7 @@ public abstract class AbstractSelect extends AbstractField<Object> implements | |||
// TODO clean this up - type is either Item.PropertySetChangeNotifier or | |||
// Property.ValueChangeNotifier | |||
HashSet<Object> captionChangeNotifiers = new HashSet<>(); | |||
HashSet<Object> captionChangeNotifiers = new HashSet<Object>(); | |||
public void addNotifierForItem(Object itemId) { | |||
switch (getItemCaptionMode()) { | |||
@@ -2038,7 +2038,7 @@ public abstract class AbstractSelect extends AbstractField<Object> implements | |||
*/ | |||
private static abstract class AbstractItemSetCriterion | |||
extends ClientSideCriterion { | |||
protected final Collection<Object> itemIds = new HashSet<>(); | |||
protected final Collection<Object> itemIds = new HashSet<Object>(); | |||
protected AbstractSelect select; | |||
public AbstractItemSetCriterion(AbstractSelect select, | |||
@@ -2213,7 +2213,7 @@ public abstract class AbstractSelect extends AbstractField<Object> implements | |||
} | |||
protected void readItems(Element design, DesignContext context) { | |||
Set<String> selected = new HashSet<>(); | |||
Set<String> selected = new HashSet<String>(); | |||
for (Element child : design.children()) { | |||
readItem(child, selected, context); | |||
} |
@@ -303,7 +303,7 @@ public class Calendar extends AbstractLegacyComponent | |||
public Calendar(String caption, CalendarEventProvider eventProvider) { | |||
registerRpc(rpc); | |||
setCaption(caption); | |||
handlers = new HashMap<>(); | |||
handlers = new HashMap<String, EventListener>(); | |||
setDefaultHandlers(); | |||
currentCalendar.setTime(new Date()); | |||
setEventProvider(eventProvider); | |||
@@ -467,7 +467,7 @@ public class Calendar extends AbstractLegacyComponent | |||
events = getEventProvider().getEvents(firstDateToShow, lastDateToShow); | |||
cacheMinMaxTimeOfDay(events); | |||
List<CalendarState.Event> calendarStateEvents = new ArrayList<>(); | |||
List<CalendarState.Event> calendarStateEvents = new ArrayList<CalendarState.Event>(); | |||
if (events != null) { | |||
for (int i = 0; i < events.size(); i++) { | |||
CalendarEvent e = events.get(i); | |||
@@ -617,9 +617,9 @@ public class Calendar extends AbstractLegacyComponent | |||
DateFormat weeklyCaptionFormatter = getWeeklyCaptionFormatter(); | |||
weeklyCaptionFormatter.setTimeZone(currentCalendar.getTimeZone()); | |||
Map<CalendarDateRange, Set<Action>> actionMap = new HashMap<>(); | |||
Map<CalendarDateRange, Set<Action>> actionMap = new HashMap<CalendarDateRange, Set<Action>>(); | |||
List<CalendarState.Day> days = new ArrayList<>(); | |||
List<CalendarState.Day> days = new ArrayList<CalendarState.Day>(); | |||
// Send all dates to client from server. This | |||
// approach was taken because gwt doesn't | |||
@@ -706,7 +706,7 @@ public class Calendar extends AbstractLegacyComponent | |||
getTimeZone()); | |||
Action[] actions = actionHandler.getActions(range, this); | |||
if (actions != null) { | |||
Set<Action> actionSet = new LinkedHashSet<>( | |||
Set<Action> actionSet = new LinkedHashSet<Action>( | |||
Arrays.asList(actions)); | |||
actionMap.put(range, actionSet); | |||
} | |||
@@ -719,7 +719,8 @@ public class Calendar extends AbstractLegacyComponent | |||
getTimeZone()); | |||
Action[] actions = actionHandler.getActions(range, this); | |||
if (actions != null) { | |||
Set<Action> actionSet = new LinkedHashSet<>(Arrays.asList(actions)); | |||
Set<Action> actionSet = new LinkedHashSet<Action>( | |||
Arrays.asList(actions)); | |||
actionMap.put(range, actionSet); | |||
} | |||
} | |||
@@ -730,7 +731,7 @@ public class Calendar extends AbstractLegacyComponent | |||
return null; | |||
} | |||
List<CalendarState.Action> calendarActions = new ArrayList<>(); | |||
List<CalendarState.Action> calendarActions = new ArrayList<CalendarState.Action>(); | |||
SimpleDateFormat formatter = new SimpleDateFormat( | |||
DateConstants.ACTION_DATE_FORMAT_PATTERN); | |||
@@ -1519,7 +1520,7 @@ public class Calendar extends AbstractLegacyComponent | |||
@Override | |||
public TargetDetails translateDropTargetDetails( | |||
Map<String, Object> clientVariables) { | |||
Map<String, Object> serverVariables = new HashMap<>(); | |||
Map<String, Object> serverVariables = new HashMap<String, Object>(); | |||
if (clientVariables.containsKey("dropSlotIndex")) { | |||
int slotIndex = (Integer) clientVariables.get("dropSlotIndex"); | |||
@@ -1704,8 +1705,8 @@ public class Calendar extends AbstractLegacyComponent | |||
public void addActionHandler(Handler actionHandler) { | |||
if (actionHandler != null) { | |||
if (actionHandlers == null) { | |||
actionHandlers = new LinkedList<>(); | |||
actionMapper = new KeyMapper<>(); | |||
actionHandlers = new LinkedList<Handler>(); | |||
actionMapper = new KeyMapper<Action>(); | |||
} | |||
if (!actionHandlers.contains(actionHandler)) { | |||
actionHandlers.add(actionHandler); |
@@ -672,7 +672,7 @@ public class ComboBox extends AbstractSelect | |||
protected List<?> getFilteredOptions() { | |||
if (!isFilteringNeeded()) { | |||
prevfilterstring = null; | |||
filteredOptions = new LinkedList<>(getItemIds()); | |||
filteredOptions = new LinkedList<Object>(getItemIds()); | |||
return filteredOptions; | |||
} | |||
@@ -689,7 +689,7 @@ public class ComboBox extends AbstractSelect | |||
} | |||
prevfilterstring = filterstring; | |||
filteredOptions = new LinkedList<>(); | |||
filteredOptions = new LinkedList<Object>(); | |||
for (final Iterator<?> it = items.iterator(); it.hasNext();) { | |||
final Object itemId = it.next(); | |||
String caption = getItemCaption(itemId); |
@@ -160,7 +160,7 @@ public class DateField extends AbstractField<Date> implements | |||
private TimeZone timeZone = null; | |||
private static Map<Resolution, String> variableNameForResolution = new HashMap<>(); | |||
private static Map<Resolution, String> variableNameForResolution = new HashMap<Resolution, String>(); | |||
private String dateOutOfRangeMessage = "Date is out of allowed range"; | |||
@@ -502,7 +502,7 @@ public class DateField extends AbstractField<Date> implements | |||
// Gets the new date in parts | |||
boolean hasChanges = false; | |||
Map<Resolution, Integer> calendarFieldChanges = new HashMap<>(); | |||
Map<Resolution, Integer> calendarFieldChanges = new HashMap<Resolution, Integer>(); | |||
for (Resolution r : Resolution | |||
.getResolutionsHigherOrEqualTo(resolution)) { |
@@ -98,7 +98,7 @@ public class Form extends AbstractField<Object> | |||
/** | |||
* Ordered list of property ids in this editor. | |||
*/ | |||
private final LinkedList<Object> propertyIds = new LinkedList<>(); | |||
private final LinkedList<Object> propertyIds = new LinkedList<Object>(); | |||
/** | |||
* Current buffered source exception. | |||
@@ -113,12 +113,12 @@ public class Form extends AbstractField<Object> | |||
/** | |||
* Mapping from propertyName to corresponding field. | |||
*/ | |||
private final HashMap<Object, Field<?>> fields = new HashMap<>(); | |||
private final HashMap<Object, Field<?>> fields = new HashMap<Object, Field<?>>(); | |||
/** | |||
* Form may act as an Item, its own properties are stored here. | |||
*/ | |||
private final HashMap<Object, Property<?>> ownProperties = new HashMap<>(); | |||
private final HashMap<Object, Property<?>> ownProperties = new HashMap<Object, Property<?>>(); | |||
/** | |||
* Field factory for this form. | |||
@@ -345,7 +345,7 @@ public class Form extends AbstractField<Object> | |||
} | |||
} catch (final Buffered.SourceException e) { | |||
if (problems == null) { | |||
problems = new LinkedList<>(); | |||
problems = new LinkedList<SourceException>(); | |||
} | |||
problems.add(e); | |||
} | |||
@@ -389,7 +389,7 @@ public class Form extends AbstractField<Object> | |||
fields.get(i.next()).discard(); | |||
} catch (final Buffered.SourceException e) { | |||
if (problems == null) { | |||
problems = new LinkedList<>(); | |||
problems = new LinkedList<SourceException>(); | |||
} | |||
problems.add(e); | |||
} | |||
@@ -1105,7 +1105,7 @@ public class Form extends AbstractField<Object> | |||
if (data instanceof Item) { | |||
item = (Item) data; | |||
} else if (data != null) { | |||
item = new BeanItem<>(data); | |||
item = new BeanItem<Object>(data); | |||
} | |||
// Sets the datasource to form | |||
@@ -1149,7 +1149,7 @@ public class Form extends AbstractField<Object> | |||
* the visibleProperties to set. | |||
*/ | |||
public void setVisibleItemProperties(Object... visibleProperties) { | |||
LinkedList<Object> v = new LinkedList<>(); | |||
LinkedList<Object> v = new LinkedList<Object>(); | |||
for (int i = 0; i < visibleProperties.length; i++) { | |||
v.add(visibleProperties[i]); | |||
} |
@@ -341,19 +341,19 @@ public class Grid extends AbstractComponent | |||
* client. Details components get destroyed once they scroll out of | |||
* view. | |||
*/ | |||
private final Map<Object, Component> itemIdToDetailsComponent = new HashMap<>(); | |||
private final Map<Object, Component> itemIdToDetailsComponent = new HashMap<Object, Component>(); | |||
/** | |||
* Set of item ids that got <code>null</code> from DetailsGenerator when | |||
* {@link DetailsGenerator#getDetails(RowReference)} was called. | |||
*/ | |||
private final Set<Object> emptyDetails = new HashSet<>(); | |||
private final Set<Object> emptyDetails = new HashSet<Object>(); | |||
/** | |||
* Set of item IDs for all open details rows. Contains even the ones | |||
* that are not currently visible on the client. | |||
*/ | |||
private final Set<Object> openDetails = new HashSet<>(); | |||
private final Set<Object> openDetails = new HashSet<Object>(); | |||
public DetailComponentManager(Grid grid) { | |||
this(grid, DetailsGenerator.NULL); | |||
@@ -438,7 +438,7 @@ public class Grid extends AbstractComponent | |||
* Recreates all visible details components. | |||
*/ | |||
public void refreshDetails() { | |||
Set<Object> visibleItemIds = new HashSet<>( | |||
Set<Object> visibleItemIds = new HashSet<Object>( | |||
itemIdToDetailsComponent.keySet()); | |||
for (Object itemId : visibleItemIds) { | |||
destroyDetails(itemId); | |||
@@ -572,7 +572,7 @@ public class Grid extends AbstractComponent | |||
@Override | |||
protected void bindFields() { | |||
List<Field<?>> fields = new ArrayList<>(getFields()); | |||
List<Field<?>> fields = new ArrayList<Field<?>>(getFields()); | |||
Item itemDataSource = getItemDataSource(); | |||
if (itemDataSource == null) { | |||
@@ -746,7 +746,7 @@ public class Grid extends AbstractComponent | |||
private CommitException cause; | |||
private Set<Column> errorColumns = new HashSet<>(); | |||
private Set<Column> errorColumns = new HashSet<Column>(); | |||
private String userErrorMessage; | |||
@@ -1408,7 +1408,7 @@ public class Grid extends AbstractComponent | |||
@Deprecated | |||
public static abstract class AbstractSelectionModel extends | |||
AbstractGridExtension implements SelectionModel, DataGenerator { | |||
protected final LinkedHashSet<Object> selection = new LinkedHashSet<>(); | |||
protected final LinkedHashSet<Object> selection = new LinkedHashSet<Object>(); | |||
@Override | |||
public boolean isSelected(final Object itemId) { | |||
@@ -1417,7 +1417,7 @@ public class Grid extends AbstractComponent | |||
@Override | |||
public Collection<Object> getSelectedRows() { | |||
return new ArrayList<>(selection); | |||
return new ArrayList<Object>(selection); | |||
} | |||
@Override | |||
@@ -1657,7 +1657,7 @@ public class Grid extends AbstractComponent | |||
@Override | |||
public void select(List<String> rowKeys) { | |||
List<Object> items = new ArrayList<>(); | |||
List<Object> items = new ArrayList<Object>(); | |||
for (String rowKey : rowKeys) { | |||
items.add(getItemId(rowKey)); | |||
} | |||
@@ -1666,7 +1666,7 @@ public class Grid extends AbstractComponent | |||
@Override | |||
public void deselect(List<String> rowKeys) { | |||
List<Object> items = new ArrayList<>(); | |||
List<Object> items = new ArrayList<Object>(); | |||
for (String rowKey : rowKeys) { | |||
items.add(getItemId(rowKey)); | |||
} | |||
@@ -1720,7 +1720,8 @@ public class Grid extends AbstractComponent | |||
final boolean selectionWillChange = !selection.containsAll(itemIds) | |||
&& selection.size() < selectionLimit; | |||
if (selectionWillChange) { | |||
final HashSet<Object> oldSelection = new HashSet<>(selection); | |||
final HashSet<Object> oldSelection = new HashSet<Object>( | |||
selection); | |||
if (selection.size() + itemIds.size() >= selectionLimit) { | |||
// Add one at a time if there's a risk of overflow | |||
Iterator<?> iterator = itemIds.iterator(); | |||
@@ -1807,7 +1808,8 @@ public class Grid extends AbstractComponent | |||
final boolean hasCommonElements = !Collections.disjoint(itemIds, | |||
selection); | |||
if (hasCommonElements) { | |||
final HashSet<Object> oldSelection = new HashSet<>(selection); | |||
final HashSet<Object> oldSelection = new HashSet<Object>( | |||
selection); | |||
selection.removeAll(itemIds); | |||
fireSelectionEvent(oldSelection, selection); | |||
} | |||
@@ -1890,7 +1892,7 @@ public class Grid extends AbstractComponent | |||
checkItemIdsExist(itemIds); | |||
boolean changed = false; | |||
Set<Object> selectedRows = new HashSet<>(itemIds); | |||
Set<Object> selectedRows = new HashSet<Object>(itemIds); | |||
final Collection<Object> oldSelection = getSelectedRows(); | |||
Set<Object> added = getDifference(selectedRows, selection); | |||
if (!added.isEmpty()) { | |||
@@ -1931,7 +1933,7 @@ public class Grid extends AbstractComponent | |||
*/ | |||
private static Set<Object> getDifference(Set<Object> set1, | |||
Set<Object> set2) { | |||
Set<Object> diff = new HashSet<>(set1); | |||
Set<Object> diff = new HashSet<Object>(set1); | |||
diff.removeAll(set2); | |||
return diff; | |||
} | |||
@@ -2311,8 +2313,8 @@ public class Grid extends AbstractComponent | |||
private RowState rowState = new RowState(); | |||
protected StaticSection<?> section; | |||
private Map<Object, CELLTYPE> cells = new LinkedHashMap<>(); | |||
private Map<Set<CELLTYPE>, CELLTYPE> cellGroups = new HashMap<>(); | |||
private Map<Object, CELLTYPE> cells = new LinkedHashMap<Object, CELLTYPE>(); | |||
private Map<Set<CELLTYPE>, CELLTYPE> cellGroups = new HashMap<Set<CELLTYPE>, CELLTYPE>(); | |||
protected StaticRow(StaticSection<?> section) { | |||
this.section = section; | |||
@@ -2397,7 +2399,7 @@ public class Grid extends AbstractComponent | |||
public CELLTYPE join(Object... propertyIds) { | |||
assert propertyIds.length > 1 : "You need to merge at least 2 properties"; | |||
Set<CELLTYPE> cells = new HashSet<>(); | |||
Set<CELLTYPE> cells = new HashSet<CELLTYPE>(); | |||
for (int i = 0; i < propertyIds.length; ++i) { | |||
cells.add(getCell(propertyIds[i])); | |||
} | |||
@@ -2415,7 +2417,7 @@ public class Grid extends AbstractComponent | |||
public CELLTYPE join(CELLTYPE... cells) { | |||
assert cells.length > 1 : "You need to merge at least 2 cells"; | |||
return join(new HashSet<>(Arrays.asList(cells))); | |||
return join(new HashSet<CELLTYPE>(Arrays.asList(cells))); | |||
} | |||
protected CELLTYPE join(Set<CELLTYPE> cells) { | |||
@@ -2432,7 +2434,7 @@ public class Grid extends AbstractComponent | |||
// Create new cell data for the group | |||
CELLTYPE newCell = createCell(); | |||
Set<String> columnGroup = new HashSet<>(); | |||
Set<String> columnGroup = new HashSet<String>(); | |||
for (CELLTYPE cell : cells) { | |||
columnGroup.add(cell.getColumnId()); | |||
} | |||
@@ -2481,7 +2483,7 @@ public class Grid extends AbstractComponent | |||
*/ | |||
protected void writeDesign(Element trElement, | |||
DesignContext designContext) { | |||
Set<CELLTYPE> visited = new HashSet<>(); | |||
Set<CELLTYPE> visited = new HashSet<CELLTYPE>(); | |||
for (Grid.Column column : section.grid.getColumns()) { | |||
CELLTYPE cell = getCell(column.getPropertyId()); | |||
if (visited.contains(cell)) { | |||
@@ -2533,7 +2535,7 @@ public class Grid extends AbstractComponent | |||
int colspan = DesignAttributeHandler.readAttribute( | |||
"colspan", element.attributes(), 1, int.class); | |||
Set<CELLTYPE> cells = new HashSet<>(); | |||
Set<CELLTYPE> cells = new HashSet<CELLTYPE>(); | |||
for (int c = 0; c < colspan; ++c) { | |||
cells.add(getCell(section.grid.getColumns() | |||
.get(columnIndex + c).getPropertyId())); | |||
@@ -2774,7 +2776,7 @@ public class Grid extends AbstractComponent | |||
} | |||
protected Grid grid; | |||
protected List<ROWTYPE> rows = new ArrayList<>(); | |||
protected List<ROWTYPE> rows = new ArrayList<ROWTYPE>(); | |||
/** | |||
* Sets the visibility of the whole section. | |||
@@ -4517,17 +4519,17 @@ public class Grid extends AbstractComponent | |||
/** | |||
* Property id to column instance mapping | |||
*/ | |||
private final Map<Object, Column> columns = new HashMap<>(); | |||
private final Map<Object, Column> columns = new HashMap<Object, Column>(); | |||
/** | |||
* Key generator for column server-to-client communication | |||
*/ | |||
private final KeyMapper<Object> columnKeys = new KeyMapper<>(); | |||
private final KeyMapper<Object> columnKeys = new KeyMapper<Object>(); | |||
/** | |||
* The current sort order | |||
*/ | |||
private final List<SortOrder> sortOrder = new ArrayList<>(); | |||
private final List<SortOrder> sortOrder = new ArrayList<SortOrder>(); | |||
/** | |||
* Property listener for listening to changes in data source properties. | |||
@@ -4540,7 +4542,7 @@ public class Grid extends AbstractComponent | |||
event.getContainer().getContainerPropertyIds()); | |||
// Find columns that need to be removed. | |||
List<Column> removedColumns = new LinkedList<>(); | |||
List<Column> removedColumns = new LinkedList<Column>(); | |||
for (Object propertyId : columns.keySet()) { | |||
if (!properties.contains(propertyId)) { | |||
removedColumns.add(getColumn(propertyId)); | |||
@@ -4556,7 +4558,7 @@ public class Grid extends AbstractComponent | |||
datasourceExtension.columnsRemoved(removedColumns); | |||
// Add new columns | |||
List<Column> addedColumns = new LinkedList<>(); | |||
List<Column> addedColumns = new LinkedList<Column>(); | |||
for (Object propertyId : properties) { | |||
if (!columns.containsKey(propertyId)) { | |||
addedColumns.add(appendColumn(propertyId)); | |||
@@ -4621,7 +4623,7 @@ public class Grid extends AbstractComponent | |||
* Poperty ID to Field mapping that stores editor fields set by | |||
* {@link #setEditorField(Object, Field)}. | |||
*/ | |||
private Map<Object, Field<?>> editorFields = new HashMap<>(); | |||
private Map<Object, Field<?>> editorFields = new HashMap<Object, Field<?>>(); | |||
private CellStyleGenerator cellStyleGenerator; | |||
private RowStyleGenerator rowStyleGenerator; | |||
@@ -4643,7 +4645,7 @@ public class Grid extends AbstractComponent | |||
private DetailComponentManager detailComponentManager = null; | |||
private Set<Component> extensionComponents = new HashSet<>(); | |||
private Set<Component> extensionComponents = new HashSet<Component>(); | |||
private static final Method SELECTION_CHANGE_METHOD = ReflectTools | |||
.findMethod(SelectionListener.class, "select", | |||
@@ -4726,7 +4728,8 @@ public class Grid extends AbstractComponent | |||
boolean userOriginated) { | |||
assert columnIds.length == directions.length; | |||
List<SortOrder> order = new ArrayList<>(columnIds.length); | |||
List<SortOrder> order = new ArrayList<SortOrder>( | |||
columnIds.length); | |||
for (int i = 0; i < columnIds.length; i++) { | |||
Object propertyId = getPropertyIdByColumnId(columnIds[i]); | |||
order.add(new SortOrder(propertyId, directions[i])); | |||
@@ -4922,7 +4925,7 @@ public class Grid extends AbstractComponent | |||
errorMessage = event.getUserErrorMessage(); | |||
errorColumnIds = new ArrayList<>(); | |||
errorColumnIds = new ArrayList<String>(); | |||
for (Column column : event.getErrorColumns()) { | |||
errorColumnIds.add(column.state.id); | |||
} | |||
@@ -5147,7 +5150,7 @@ public class Grid extends AbstractComponent | |||
* @return unmodifiable copy of current columns in visual order | |||
*/ | |||
public List<Column> getColumns() { | |||
List<Column> columns = new ArrayList<>(); | |||
List<Column> columns = new ArrayList<Column>(); | |||
for (String columnId : getState(false).columnOrder) { | |||
columns.add(getColumnByColumnId(columnId)); | |||
} | |||
@@ -5190,7 +5193,7 @@ public class Grid extends AbstractComponent | |||
// Inform the data provider of this new column. | |||
Column column = getColumn(propertyId); | |||
List<Column> addedColumns = new ArrayList<>(); | |||
List<Column> addedColumns = new ArrayList<Column>(); | |||
addedColumns.add(column); | |||
datasourceExtension.columnsAdded(addedColumns); | |||
@@ -5255,8 +5258,8 @@ public class Grid extends AbstractComponent | |||
* Removes all columns from this Grid. | |||
*/ | |||
public void removeAllColumns() { | |||
List<Column> removed = new ArrayList<>(columns.values()); | |||
Set<Object> properties = new HashSet<>(columns.keySet()); | |||
List<Column> removed = new ArrayList<Column>(columns.values()); | |||
Set<Object> properties = new HashSet<Object>(columns.keySet()); | |||
for (Object propertyId : properties) { | |||
removeColumn(propertyId); | |||
} | |||
@@ -5402,7 +5405,7 @@ public class Grid extends AbstractComponent | |||
"There is no column for given property id " + propertyId); | |||
} | |||
List<Column> removed = new ArrayList<>(); | |||
List<Column> removed = new ArrayList<Column>(); | |||
removed.add(getColumn(propertyId)); | |||
internalRemoveColumn(propertyId); | |||
datasourceExtension.columnsRemoved(removed); | |||
@@ -5435,12 +5438,12 @@ public class Grid extends AbstractComponent | |||
"The propertyIds array contains duplicates: " | |||
+ SharedUtil.getDuplicates(propertyIds)); | |||
} | |||
Set<?> removePids = new HashSet<>(columns.keySet()); | |||
Set<?> removePids = new HashSet<Object>(columns.keySet()); | |||
removePids.removeAll(Arrays.asList(propertyIds)); | |||
for (Object removePid : removePids) { | |||
removeColumn(removePid); | |||
} | |||
Set<?> addPids = new HashSet<>(Arrays.asList(propertyIds)); | |||
Set<?> addPids = new HashSet<Object>(Arrays.asList(propertyIds)); | |||
addPids.removeAll(columns.keySet()); | |||
for (Object propertyId : addPids) { | |||
addColumn(propertyId); | |||
@@ -5462,7 +5465,7 @@ public class Grid extends AbstractComponent | |||
"The propertyIds array contains duplicates: " | |||
+ SharedUtil.getDuplicates(propertyIds)); | |||
} | |||
List<String> columnOrder = new ArrayList<>(); | |||
List<String> columnOrder = new ArrayList<String>(); | |||
for (Object propertyId : propertyIds) { | |||
if (columns.containsKey(propertyId)) { | |||
columnOrder.add(columnKeys.key(propertyId)); | |||
@@ -6238,7 +6241,7 @@ public class Grid extends AbstractComponent | |||
getState().sortColumns = new String[] {}; | |||
getState(false).sortDirs = new SortDirection[] {}; | |||
} | |||
fireEvent(new SortEvent(this, new ArrayList<>(sortOrder), | |||
fireEvent(new SortEvent(this, new ArrayList<SortOrder>(sortOrder), | |||
userOriginated)); | |||
} else { | |||
throw new IllegalStateException( | |||
@@ -6579,7 +6582,7 @@ public class Grid extends AbstractComponent | |||
public Iterator<Component> iterator() { | |||
// This is a hash set to avoid adding header/footer components inside | |||
// merged cells multiple times | |||
LinkedHashSet<Component> componentList = new LinkedHashSet<>(); | |||
LinkedHashSet<Component> componentList = new LinkedHashSet<Component>(); | |||
Header header = getHeader(); | |||
for (int i = 0; i < header.getRowCount(); ++i) { |
@@ -50,7 +50,7 @@ import com.vaadin.v7.shared.ui.optiongroup.OptionGroupState; | |||
public class OptionGroup extends AbstractSelect | |||
implements FieldEvents.BlurNotifier, FieldEvents.FocusNotifier { | |||
private Set<Object> disabledItemIds = new HashSet<>(); | |||
private Set<Object> disabledItemIds = new HashSet<Object>(); | |||
public OptionGroup() { | |||
super(); |
@@ -389,57 +389,57 @@ public class Table extends AbstractSelect implements Action.Container, | |||
/** | |||
* Keymapper for column ids. | |||
*/ | |||
private final KeyMapper<Object> columnIdMap = new KeyMapper<>(); | |||
private final KeyMapper<Object> columnIdMap = new KeyMapper<Object>(); | |||
/** | |||
* Holds visible column propertyIds - in order. | |||
*/ | |||
private LinkedList<Object> visibleColumns = new LinkedList<>(); | |||
private LinkedList<Object> visibleColumns = new LinkedList<Object>(); | |||
/** | |||
* Holds noncollapsible columns. | |||
*/ | |||
private HashSet<Object> noncollapsibleColumns = new HashSet<>(); | |||
private HashSet<Object> noncollapsibleColumns = new HashSet<Object>(); | |||
/** | |||
* Holds propertyIds of currently collapsed columns. | |||
*/ | |||
private final HashSet<Object> collapsedColumns = new HashSet<>(); | |||
private final HashSet<Object> collapsedColumns = new HashSet<Object>(); | |||
/** | |||
* Holds headers for visible columns (by propertyId). | |||
*/ | |||
private final HashMap<Object, String> columnHeaders = new HashMap<>(); | |||
private final HashMap<Object, String> columnHeaders = new HashMap<Object, String>(); | |||
/** | |||
* Holds footers for visible columns (by propertyId). | |||
*/ | |||
private final HashMap<Object, String> columnFooters = new HashMap<>(); | |||
private final HashMap<Object, String> columnFooters = new HashMap<Object, String>(); | |||
/** | |||
* Holds icons for visible columns (by propertyId). | |||
*/ | |||
private final HashMap<Object, Resource> columnIcons = new HashMap<>(); | |||
private final HashMap<Object, Resource> columnIcons = new HashMap<Object, Resource>(); | |||
/** | |||
* Holds alignments for visible columns (by propertyId). | |||
*/ | |||
private HashMap<Object, Align> columnAlignments = new HashMap<>(); | |||
private HashMap<Object, Align> columnAlignments = new HashMap<Object, Align>(); | |||
/** | |||
* Holds column widths in pixels for visible columns (by propertyId). | |||
*/ | |||
private final HashMap<Object, Integer> columnWidths = new HashMap<>(); | |||
private final HashMap<Object, Integer> columnWidths = new HashMap<Object, Integer>(); | |||
/** | |||
* Holds column expand rations for visible columns (by propertyId). | |||
*/ | |||
private final HashMap<Object, Float> columnExpandRatios = new HashMap<>(); | |||
private final HashMap<Object, Float> columnExpandRatios = new HashMap<Object, Float>(); | |||
/** | |||
* Holds column generators | |||
*/ | |||
private final HashMap<Object, ColumnGenerator> columnGenerators = new LinkedHashMap<>(); | |||
private final HashMap<Object, ColumnGenerator> columnGenerators = new LinkedHashMap<Object, ColumnGenerator>(); | |||
/** | |||
* Holds value of property pageLength. 0 disables paging. | |||
@@ -592,11 +592,11 @@ public class Table extends AbstractSelect implements Action.Container, | |||
private RowGenerator rowGenerator = null; | |||
private final Map<Field<?>, Property<?>> associatedProperties = new HashMap<>(); | |||
private final Map<Field<?>, Property<?>> associatedProperties = new HashMap<Field<?>, Property<?>>(); | |||
private boolean painted = false; | |||
private HashMap<Object, Converter<String, Object>> propertyValueConverters = new HashMap<>(); | |||
private HashMap<Object, Converter<String, Object>> propertyValueConverters = new HashMap<Object, Converter<String, Object>>(); | |||
/** | |||
* Set to true if the client-side should be informed that the key mapper has | |||
@@ -605,7 +605,7 @@ public class Table extends AbstractSelect implements Action.Container, | |||
*/ | |||
private boolean keyMapperReset; | |||
private List<Throwable> exceptionsDuringCachePopulation = new ArrayList<>(); | |||
private List<Throwable> exceptionsDuringCachePopulation = new ArrayList<Throwable>(); | |||
private boolean isBeingPainted; | |||
@@ -689,7 +689,7 @@ public class Table extends AbstractSelect implements Action.Container, | |||
"Can not set visible columns to null value"); | |||
} | |||
final LinkedList<Object> newVC = new LinkedList<>(); | |||
final LinkedList<Object> newVC = new LinkedList<Object>(); | |||
// Checks that the new visible columns contains no nulls, properties | |||
// exist and that there are no duplicates before adding them to newVC. | |||
@@ -894,7 +894,7 @@ public class Table extends AbstractSelect implements Action.Container, | |||
} | |||
// Resets the alignments | |||
final HashMap<Object, Align> newCA = new HashMap<>(); | |||
final HashMap<Object, Align> newCA = new HashMap<Object, Align>(); | |||
int i = 0; | |||
for (final Iterator<Object> it = visibleColumns.iterator(); it.hasNext() | |||
&& i < columnAlignments.length; i++) { | |||
@@ -1471,7 +1471,7 @@ public class Table extends AbstractSelect implements Action.Container, | |||
if (columnOrder == null || !isColumnReorderingAllowed()) { | |||
return; | |||
} | |||
final LinkedList<Object> newOrder = new LinkedList<>(); | |||
final LinkedList<Object> newOrder = new LinkedList<Object>(); | |||
for (int i = 0; i < columnOrder.length; i++) { | |||
if (columnOrder[i] != null | |||
&& visibleColumns.contains(columnOrder[i])) { | |||
@@ -2202,8 +2202,8 @@ public class Table extends AbstractSelect implements Action.Container, | |||
if (replaceListeners) { | |||
// initialize the listener collections, this should only be done if | |||
// the entire cache is refreshed (through refreshRenderedCells) | |||
listenedProperties = new HashSet<>(); | |||
visibleComponents = new HashSet<>(); | |||
listenedProperties = new HashSet<Property<?>>(); | |||
visibleComponents = new HashSet<Component>(); | |||
} | |||
Object[][] cells = new Object[cols + CELL_FIRSTCOL][rows]; | |||
@@ -2644,7 +2644,7 @@ public class Table extends AbstractSelect implements Action.Container, | |||
throws UnsupportedOperationException { | |||
// remove generated columns from the list of columns being assigned | |||
final LinkedList<Object> availableCols = new LinkedList<>(); | |||
final LinkedList<Object> availableCols = new LinkedList<Object>(); | |||
for (Iterator<Object> it = visibleColumns.iterator(); it.hasNext();) { | |||
Object id = it.next(); | |||
if (!columnGenerators.containsKey(id)) { | |||
@@ -2735,7 +2735,7 @@ public class Table extends AbstractSelect implements Action.Container, | |||
} else { | |||
generated = Collections.emptyList(); | |||
} | |||
List<Object> visibleIds = new ArrayList<>(); | |||
List<Object> visibleIds = new ArrayList<Object>(); | |||
if (generated.isEmpty()) { | |||
visibleIds.addAll(newDataSource.getContainerPropertyIds()); | |||
} else { | |||
@@ -2777,7 +2777,7 @@ public class Table extends AbstractSelect implements Action.Container, | |||
newDataSource = new IndexedContainer(); | |||
} | |||
if (visibleIds == null) { | |||
visibleIds = new ArrayList<>(); | |||
visibleIds = new ArrayList<Object>(); | |||
} | |||
// Retain propertyValueConverters if their corresponding ids are | |||
@@ -2786,7 +2786,7 @@ public class Table extends AbstractSelect implements Action.Container, | |||
if (propertyValueConverters != null) { | |||
Collection<?> newPropertyIds = newDataSource | |||
.getContainerPropertyIds(); | |||
LinkedList<Object> retainableValueConverters = new LinkedList<>(); | |||
LinkedList<Object> retainableValueConverters = new LinkedList<Object>(); | |||
for (Object propertyId : newPropertyIds) { | |||
Converter<String, ?> converter = getConverter(propertyId); | |||
if (converter != null) { | |||
@@ -2819,7 +2819,7 @@ public class Table extends AbstractSelect implements Action.Container, | |||
} | |||
// don't add the same id twice | |||
Collection<Object> col = new LinkedList<>(); | |||
Collection<Object> col = new LinkedList<Object>(); | |||
for (Iterator<?> it = visibleIds.iterator(); it.hasNext();) { | |||
Object id = it.next(); | |||
if (!col.contains(id)) { | |||
@@ -2860,7 +2860,7 @@ public class Table extends AbstractSelect implements Action.Container, | |||
*/ | |||
private LinkedHashSet<Object> getItemIdsInRange(Object itemId, | |||
final int length) { | |||
LinkedHashSet<Object> ids = new LinkedHashSet<>(); | |||
LinkedHashSet<Object> ids = new LinkedHashSet<Object>(); | |||
for (int i = 0; i < length; i++) { | |||
assert itemId != null; // should not be null unless client-server | |||
// are out of sync | |||
@@ -2883,7 +2883,7 @@ public class Table extends AbstractSelect implements Action.Container, | |||
Set<Object> renderedButNotSelectedItemIds = getCurrentlyRenderedItemIds(); | |||
@SuppressWarnings("unchecked") | |||
HashSet<Object> newValue = new LinkedHashSet<>( | |||
HashSet<Object> newValue = new LinkedHashSet<Object>( | |||
(Collection<Object>) getValue()); | |||
if (variables.containsKey("clearSelections")) { | |||
@@ -2938,7 +2938,7 @@ public class Table extends AbstractSelect implements Action.Container, | |||
} | |||
private Set<Object> getCurrentlyRenderedItemIds() { | |||
HashSet<Object> ids = new HashSet<>(); | |||
HashSet<Object> ids = new HashSet<Object>(); | |||
if (pageBuffer != null) { | |||
for (int i = 0; i < pageBuffer[CELL_ITEMID].length; i++) { | |||
ids.add(pageBuffer[CELL_ITEMID][i]); | |||
@@ -2971,7 +2971,7 @@ public class Table extends AbstractSelect implements Action.Container, | |||
if (!isSelectable() && variables.containsKey("selected")) { | |||
// Not-selectable is a special case, AbstractSelect does not support | |||
// TODO could be optimized. | |||
variables = new HashMap<>(variables); | |||
variables = new HashMap<String, Object>(variables); | |||
variables.remove("selected"); | |||
} | |||
@@ -2983,7 +2983,7 @@ public class Table extends AbstractSelect implements Action.Container, | |||
&& variables.containsKey("selected") | |||
&& multiSelectMode == MultiSelectMode.DEFAULT) { | |||
handleSelectedItems(variables); | |||
variables = new HashMap<>(variables); | |||
variables = new HashMap<String, Object>(variables); | |||
variables.remove("selected"); | |||
} | |||
@@ -3082,7 +3082,7 @@ public class Table extends AbstractSelect implements Action.Container, | |||
try { | |||
final Object[] ids = (Object[]) variables | |||
.get("collapsedcolumns"); | |||
Set<Object> idSet = new HashSet<>(); | |||
Set<Object> idSet = new HashSet<Object>(); | |||
for (Object id : ids) { | |||
idSet.add(columnIdMap.get(id.toString())); | |||
} | |||
@@ -3648,7 +3648,7 @@ public class Table extends AbstractSelect implements Action.Container, | |||
private void paintAvailableColumns(PaintTarget target) | |||
throws PaintException { | |||
if (columnCollapsingAllowed) { | |||
final HashSet<Object> collapsedCols = new HashSet<>(); | |||
final HashSet<Object> collapsedCols = new HashSet<Object>(); | |||
for (Object colId : visibleColumns) { | |||
if (isColumnCollapsed(colId)) { | |||
collapsedCols.add(colId); | |||
@@ -3772,7 +3772,7 @@ public class Table extends AbstractSelect implements Action.Container, | |||
private void paintVisibleColumnOrder(PaintTarget target) { | |||
// Visible column order | |||
final ArrayList<String> visibleColOrder = new ArrayList<>(); | |||
final ArrayList<String> visibleColOrder = new ArrayList<String>(); | |||
for (Object columnId : visibleColumns) { | |||
if (!isColumnCollapsed(columnId)) { | |||
visibleColOrder.add(columnIdMap.key(columnId)); | |||
@@ -3782,9 +3782,9 @@ public class Table extends AbstractSelect implements Action.Container, | |||
} | |||
private Set<Action> findAndPaintBodyActions(PaintTarget target) { | |||
Set<Action> actionSet = new LinkedHashSet<>(); | |||
Set<Action> actionSet = new LinkedHashSet<Action>(); | |||
if (actionHandlers != null) { | |||
final ArrayList<String> keys = new ArrayList<>(); | |||
final ArrayList<String> keys = new ArrayList<String>(); | |||
for (Handler ah : actionHandlers) { | |||
// Getting actions for the null item, which in this case means | |||
// the body item | |||
@@ -3846,7 +3846,7 @@ public class Table extends AbstractSelect implements Action.Container, | |||
} | |||
private String[] findSelectedKeys() { | |||
LinkedList<String> selectedKeys = new LinkedList<>(); | |||
LinkedList<String> selectedKeys = new LinkedList<String>(); | |||
if (isMultiSelect()) { | |||
HashSet<?> sel = new HashSet<Object>((Set<?>) getValue()); | |||
Collection<?> vids = getVisibleItemIds(); | |||
@@ -4002,7 +4002,7 @@ public class Table extends AbstractSelect implements Action.Container, | |||
// Actions | |||
if (actionHandlers != null) { | |||
final ArrayList<String> keys = new ArrayList<>(); | |||
final ArrayList<String> keys = new ArrayList<String>(); | |||
for (Handler ah : actionHandlers) { | |||
final Action[] aa = ah.getActions(itemId, this); | |||
if (aa != null) { | |||
@@ -4197,8 +4197,8 @@ public class Table extends AbstractSelect implements Action.Container, | |||
if (actionHandler != null) { | |||
if (actionHandlers == null) { | |||
actionHandlers = new LinkedList<>(); | |||
actionMapper = new KeyMapper<>(); | |||
actionHandlers = new LinkedList<Handler>(); | |||
actionMapper = new KeyMapper<Action>(); | |||
} | |||
if (!actionHandlers.contains(actionHandler)) { | |||
@@ -4534,7 +4534,7 @@ public class Table extends AbstractSelect implements Action.Container, | |||
@Override | |||
public Collection<?> getVisibleItemIds() { | |||
final LinkedList<Object> visible = new LinkedList<>(); | |||
final LinkedList<Object> visible = new LinkedList<Object>(); | |||
final Object[][] cells = getVisibleCells(); | |||
// may be null if the table has not been rendered yet (e.g. not attached | |||
@@ -4616,7 +4616,8 @@ public class Table extends AbstractSelect implements Action.Container, | |||
Collection<?> containerPropertyIds = getContainerDataSource() | |||
.getContainerPropertyIds(); | |||
LinkedList<Object> newVisibleColumns = new LinkedList<>(visibleColumns); | |||
LinkedList<Object> newVisibleColumns = new LinkedList<Object>( | |||
visibleColumns); | |||
for (Iterator<Object> iterator = newVisibleColumns.iterator(); iterator | |||
.hasNext();) { | |||
Object id = iterator.next(); | |||
@@ -6179,7 +6180,7 @@ public class Table extends AbstractSelect implements Action.Container, | |||
if (colgroup != null) { | |||
int i = 0; | |||
List<Object> pIds = new ArrayList<>(); | |||
List<Object> pIds = new ArrayList<Object>(); | |||
for (Element col : colgroup.children()) { | |||
if (!col.tagName().equals("col")) { | |||
throw new DesignException("invalid column"); | |||
@@ -6281,7 +6282,7 @@ public class Table extends AbstractSelect implements Action.Container, | |||
return; | |||
} | |||
Set<String> selected = new HashSet<>(); | |||
Set<String> selected = new HashSet<String>(); | |||
for (Element tr : tbody.children()) { | |||
readItem(tr, selected, context); | |||
} |
@@ -122,12 +122,12 @@ public class Tree extends AbstractSelect implements Container.Hierarchical, | |||
/** | |||
* Item icons alt texts. | |||
*/ | |||
private final HashMap<Object, String> itemIconAlts = new HashMap<>(); | |||
private final HashMap<Object, String> itemIconAlts = new HashMap<Object, String>(); | |||
/** | |||
* Set of expanded nodes. | |||
*/ | |||
private HashSet<Object> expanded = new HashSet<>(); | |||
private HashSet<Object> expanded = new HashSet<Object>(); | |||
/** | |||
* List of action handlers. | |||
@@ -375,7 +375,7 @@ public class Tree extends AbstractSelect implements Container.Hierarchical, | |||
boolean result = true; | |||
// Initial stack | |||
final Stack<Object> todo = new Stack<>(); | |||
final Stack<Object> todo = new Stack<Object>(); | |||
todo.add(startItemId); | |||
// Expands recursively | |||
@@ -428,7 +428,7 @@ public class Tree extends AbstractSelect implements Container.Hierarchical, | |||
boolean result = true; | |||
// Initial stack | |||
final Stack<Object> todo = new Stack<>(); | |||
final Stack<Object> todo = new Stack<Object>(); | |||
todo.add(startItemId); | |||
// Collapse recursively | |||
@@ -522,7 +522,7 @@ public class Tree extends AbstractSelect implements Container.Hierarchical, | |||
if (!isSelectable() && variables.containsKey("selected")) { | |||
// Not-selectable is a special case, AbstractSelect does not support | |||
// TODO could be optimized. | |||
variables = new HashMap<>(variables); | |||
variables = new HashMap<String, Object>(variables); | |||
variables.remove("selected"); | |||
} | |||
@@ -561,7 +561,7 @@ public class Tree extends AbstractSelect implements Container.Hierarchical, | |||
if (variables.containsKey("selected") && isMultiSelect() | |||
&& multiSelectMode == MultiSelectMode.DEFAULT) { | |||
handleSelectedItems(variables); | |||
variables = new HashMap<>(variables); | |||
variables = new HashMap<String, Object>(variables); | |||
variables.remove("selected"); | |||
} | |||
@@ -595,7 +595,7 @@ public class Tree extends AbstractSelect implements Container.Hierarchical, | |||
final String[] ka = (String[]) variables.get("selected"); | |||
// Converts the key-array to id-set | |||
final LinkedList<Object> s = new LinkedList<>(); | |||
final LinkedList<Object> s = new LinkedList<Object>(); | |||
for (int i = 0; i < ka.length; i++) { | |||
final Object id = itemIdMapper.get(ka[i]); | |||
if (!isNullSelectionAllowed() | |||
@@ -666,15 +666,15 @@ public class Tree extends AbstractSelect implements Container.Hierarchical, | |||
} | |||
// Initialize variables | |||
final Set<Action> actionSet = new LinkedHashSet<>(); | |||
final Set<Action> actionSet = new LinkedHashSet<Action>(); | |||
// rendered selectedKeys | |||
LinkedList<String> selectedKeys = new LinkedList<>(); | |||
LinkedList<String> selectedKeys = new LinkedList<String>(); | |||
final LinkedList<String> expandedKeys = new LinkedList<>(); | |||
final LinkedList<String> expandedKeys = new LinkedList<String>(); | |||
// Iterates through hierarchical tree using a stack of iterators | |||
final Stack<Iterator<?>> iteratorStack = new Stack<>(); | |||
final Stack<Iterator<?>> iteratorStack = new Stack<Iterator<?>>(); | |||
Collection<?> ids; | |||
if (partialUpdate) { | |||
ids = getChildren(expandedItemId); | |||
@@ -691,7 +691,7 @@ public class Tree extends AbstractSelect implements Container.Hierarchical, | |||
* by right clicking on the Tree body | |||
*/ | |||
if (actionHandlers != null) { | |||
final ArrayList<String> keys = new ArrayList<>(); | |||
final ArrayList<String> keys = new ArrayList<String>(); | |||
for (Handler ah : actionHandlers) { | |||
// Getting action for the null item, which in this case | |||
@@ -780,7 +780,7 @@ public class Tree extends AbstractSelect implements Container.Hierarchical, | |||
// Actions | |||
if (actionHandlers != null) { | |||
final ArrayList<String> keys = new ArrayList<>(); | |||
final ArrayList<String> keys = new ArrayList<String>(); | |||
final Iterator<Action.Handler> ahi = actionHandlers | |||
.iterator(); | |||
while (ahi.hasNext()) { | |||
@@ -1242,8 +1242,8 @@ public class Tree extends AbstractSelect implements Container.Hierarchical, | |||
if (actionHandler != null) { | |||
if (actionHandlers == null) { | |||
actionHandlers = new LinkedList<>(); | |||
actionMapper = new KeyMapper<>(); | |||
actionHandlers = new LinkedList<Handler>(); | |||
actionMapper = new KeyMapper<Action>(); | |||
} | |||
if (!actionHandlers.contains(actionHandler)) { | |||
@@ -1291,10 +1291,10 @@ public class Tree extends AbstractSelect implements Container.Hierarchical, | |||
@Override | |||
public Collection<?> getVisibleItemIds() { | |||
final LinkedList<Object> visible = new LinkedList<>(); | |||
final LinkedList<Object> visible = new LinkedList<Object>(); | |||
// Iterates trough hierarchical tree using a stack of iterators | |||
final Stack<Iterator<?>> iteratorStack = new Stack<>(); | |||
final Stack<Iterator<?>> iteratorStack = new Stack<Iterator<?>>(); | |||
final Collection<?> ids = rootItemIds(); | |||
if (ids != null) { | |||
iteratorStack.push(ids.iterator()); | |||
@@ -1844,7 +1844,7 @@ public class Tree extends AbstractSelect implements Container.Hierarchical, | |||
} | |||
private void cleanupExpandedItems() { | |||
Set<Object> removedItemIds = new HashSet<>(); | |||
Set<Object> removedItemIds = new HashSet<Object>(); | |||
for (Object expandedItemId : expanded) { | |||
if (getItem(expandedItemId) == null) { | |||
removedItemIds.add(expandedItemId); |
@@ -199,7 +199,7 @@ public class TreeTable extends Table implements Hierarchical { | |||
*/ | |||
private class HierarchicalStrategy extends AbstractStrategy { | |||
private final HashSet<Object> openItems = new HashSet<>(); | |||
private final HashSet<Object> openItems = new HashSet<Object>(); | |||
@Override | |||
public boolean isNodeOpen(Object itemId) { | |||
@@ -286,7 +286,7 @@ public class TreeTable extends Table implements Hierarchical { | |||
*/ | |||
private List<Object> getPreOrder() { | |||
if (preOrder == null) { | |||
preOrder = new ArrayList<>(); | |||
preOrder = new ArrayList<Object>(); | |||
Collection<?> rootItemIds = getContainerDataSource() | |||
.rootItemIds(); | |||
for (Object id : rootItemIds) { | |||
@@ -896,7 +896,7 @@ public class TreeTable extends Table implements Hierarchical { | |||
@Override | |||
protected List<Object> getItemIds(int firstIndex, int rows) { | |||
List<Object> itemIds = new ArrayList<>(); | |||
List<Object> itemIds = new ArrayList<Object>(); | |||
for (int i = firstIndex; i < firstIndex + rows; i++) { | |||
itemIds.add(getIdByIndex(i)); | |||
} | |||
@@ -910,8 +910,8 @@ public class TreeTable extends Table implements Hierarchical { | |||
return; | |||
} | |||
Set<String> selected = new HashSet<>(); | |||
Stack<Object> parents = new Stack<>(); | |||
Set<String> selected = new HashSet<String>(); | |||
Stack<Object> parents = new Stack<Object>(); | |||
int lastDepth = -1; | |||
for (Element tr : tbody.children()) { |
@@ -802,7 +802,7 @@ public class Upload extends AbstractLegacyComponent | |||
*/ | |||
public void addProgressListener(ProgressListener listener) { | |||
if (progressListeners == null) { | |||
progressListeners = new LinkedHashSet<>(); | |||
progressListeners = new LinkedHashSet<ProgressListener>(); | |||
} | |||
progressListeners.add(listener); | |||
} |
@@ -37,7 +37,6 @@ import com.vaadin.v7.ui.components.calendar.event.CalendarEditableEventProvider; | |||
import com.vaadin.v7.ui.components.calendar.event.CalendarEvent; | |||
import com.vaadin.v7.ui.components.calendar.event.CalendarEvent.EventChangeListener; | |||
import com.vaadin.v7.ui.components.calendar.event.CalendarEvent.EventChangeNotifier; | |||
import com.vaadin.v7.ui.components.calendar.event.CalendarEventProvider; | |||
import com.vaadin.v7.ui.components.calendar.event.CalendarEventProvider.EventSetChangeNotifier; | |||
/** | |||
@@ -85,14 +84,14 @@ public class ContainerEventProvider | |||
/** | |||
* Listeners attached to the container | |||
*/ | |||
private final List<EventSetChangeListener> eventSetChangeListeners = new LinkedList<>(); | |||
private final List<EventChangeListener> eventChangeListeners = new LinkedList<>(); | |||
private final List<EventSetChangeListener> eventSetChangeListeners = new LinkedList<EventSetChangeListener>(); | |||
private final List<EventChangeListener> eventChangeListeners = new LinkedList<EventChangeListener>(); | |||
/** | |||
* The event cache contains the events previously created by | |||
* {@link #getEvents(Date, Date)} | |||
*/ | |||
private final List<CalendarEvent> eventCache = new LinkedList<>(); | |||
private final List<CalendarEvent> eventCache = new LinkedList<CalendarEvent>(); | |||
/** | |||
* The container used as datasource |
@@ -38,7 +38,7 @@ public class BasicEvent implements EditableCalendarEvent, EventChangeNotifier { | |||
private Date end; | |||
private Date start; | |||
private String styleName; | |||
private transient List<EventChangeListener> listeners = new ArrayList<>(); | |||
private transient List<EventChangeListener> listeners = new ArrayList<EventChangeListener>(); | |||
private boolean isAllDay; | |||
@@ -46,9 +46,9 @@ import com.vaadin.v7.ui.components.calendar.event.CalendarEventProvider.EventSet | |||
public class BasicEventProvider implements CalendarEditableEventProvider, | |||
EventSetChangeNotifier, CalendarEvent.EventChangeListener { | |||
protected List<CalendarEvent> eventList = new ArrayList<>(); | |||
protected List<CalendarEvent> eventList = new ArrayList<CalendarEvent>(); | |||
private List<EventSetChangeListener> listeners = new ArrayList<>(); | |||
private List<EventSetChangeListener> listeners = new ArrayList<EventSetChangeListener>(); | |||
/* | |||
* (non-Javadoc) | |||
@@ -59,7 +59,7 @@ public class BasicEventProvider implements CalendarEditableEventProvider, | |||
*/ | |||
@Override | |||
public List<CalendarEvent> getEvents(Date startDate, Date endDate) { | |||
ArrayList<CalendarEvent> activeEvents = new ArrayList<>(); | |||
ArrayList<CalendarEvent> activeEvents = new ArrayList<CalendarEvent>(); | |||
for (CalendarEvent ev : eventList) { | |||
long from = startDate.getTime(); |
@@ -1,12 +1,12 @@ | |||
/* | |||
* Copyright 2000-2016 Vaadin Ltd. | |||
* | |||
* | |||
* Licensed under the Apache License, Version 2.0 (the "License"); you may not | |||
* use this file except in compliance with the License. You may obtain a copy of | |||
* the License at | |||
* | |||
* | |||
* http://www.apache.org/licenses/LICENSE-2.0 | |||
* | |||
* | |||
* Unless required by applicable law or agreed to in writing, software | |||
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT | |||
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the | |||
@@ -27,12 +27,12 @@ import com.vaadin.v7.shared.ui.colorpicker.ColorPickerGridState; | |||
/** | |||
* A component that represents a color selection grid within a color picker. | |||
* | |||
* | |||
* @since 7.0.0 | |||
*/ | |||
@Deprecated | |||
public class ColorPickerGrid extends AbstractComponent implements | |||
ColorSelector { | |||
public class ColorPickerGrid extends AbstractComponent | |||
implements ColorSelector { | |||
private static final String STYLENAME = "v-colorpicker-grid"; | |||
@@ -86,7 +86,7 @@ public class ColorPickerGrid extends AbstractComponent implements | |||
private Color[][] colorGrid = new Color[1][1]; | |||
/** The changed colors. */ | |||
private final Map<Point, Color> changedColors = new HashMap<>(); | |||
private final Map<Point, Color> changedColors = new HashMap<Point, Color>(); | |||
/** | |||
* Instantiates a new color picker grid. | |||
@@ -100,7 +100,7 @@ public class ColorPickerGrid extends AbstractComponent implements | |||
/** | |||
* Instantiates a new color picker grid. | |||
* | |||
* | |||
* @param rows | |||
* the rows | |||
* @param columns | |||
@@ -115,7 +115,7 @@ public class ColorPickerGrid extends AbstractComponent implements | |||
/** | |||
* Instantiates a new color picker grid. | |||
* | |||
* | |||
* @param colors | |||
* the colors | |||
*/ | |||
@@ -164,7 +164,7 @@ public class ColorPickerGrid extends AbstractComponent implements | |||
/** | |||
* Sets the color grid. | |||
* | |||
* | |||
* @param colors | |||
* the new color grid | |||
*/ | |||
@@ -185,7 +185,7 @@ public class ColorPickerGrid extends AbstractComponent implements | |||
/** | |||
* Adds a color change listener | |||
* | |||
* | |||
* @param listener | |||
* The color change listener | |||
*/ | |||
@@ -201,7 +201,7 @@ public class ColorPickerGrid extends AbstractComponent implements | |||
/** | |||
* Removes a color change listener | |||
* | |||
* | |||
* @param listener | |||
* The listener | |||
*/ | |||
@@ -220,7 +220,7 @@ public class ColorPickerGrid extends AbstractComponent implements | |||
/** | |||
* Sets the position. | |||
* | |||
* | |||
* @param x | |||
* the x | |||
* @param y | |||
@@ -235,7 +235,7 @@ public class ColorPickerGrid extends AbstractComponent implements | |||
/** | |||
* Gets the position. | |||
* | |||
* | |||
* @return the position | |||
*/ | |||
public int[] getPosition() { | |||
@@ -244,7 +244,7 @@ public class ColorPickerGrid extends AbstractComponent implements | |||
/** | |||
* Notifies the listeners that a color change has occurred | |||
* | |||
* | |||
* @param color | |||
* The color which it changed to | |||
*/ |
@@ -1,12 +1,12 @@ | |||
/* | |||
* Copyright 2000-2016 Vaadin Ltd. | |||
* | |||
* | |||
* Licensed under the Apache License, Version 2.0 (the "License"); you may not | |||
* use this file except in compliance with the License. You may obtain a copy of | |||
* the License at | |||
* | |||
* | |||
* http://www.apache.org/licenses/LICENSE-2.0 | |||
* | |||
* | |||
* Unless required by applicable law or agreed to in writing, software | |||
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT | |||
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the | |||
@@ -28,12 +28,12 @@ import com.vaadin.v7.shared.ui.colorpicker.Color; | |||
/** | |||
* A component that represents color selection history within a color picker. | |||
* | |||
* | |||
* @since 7.0.0 | |||
*/ | |||
@Deprecated | |||
public class ColorPickerHistory extends CustomComponent implements | |||
ColorSelector, ColorChangeListener { | |||
public class ColorPickerHistory extends CustomComponent | |||
implements ColorSelector, ColorChangeListener { | |||
private static final String STYLENAME = "v-colorpicker-history"; | |||
@@ -56,7 +56,7 @@ public class ColorPickerHistory extends CustomComponent implements | |||
private static final int columns = 15; | |||
/** Temporary color history for when the component is detached. */ | |||
private ArrayBlockingQueue<Color> tempHistory = new ArrayBlockingQueue<>( | |||
private ArrayBlockingQueue<Color> tempHistory = new ArrayBlockingQueue<Color>( | |||
rows * columns); | |||
/** The grid. */ | |||
@@ -83,7 +83,7 @@ public class ColorPickerHistory extends CustomComponent implements | |||
} | |||
private void createColorHistoryIfNecessary() { | |||
List<Color> tempColors = new ArrayList<>(tempHistory); | |||
List<Color> tempColors = new ArrayList<Color>(tempHistory); | |||
if (getSession().getAttribute("colorPickerHistory") == null) { | |||
getSession().setAttribute("colorPickerHistory", | |||
new ArrayBlockingQueue<Color>(rows * columns)); | |||
@@ -97,8 +97,8 @@ public class ColorPickerHistory extends CustomComponent implements | |||
@SuppressWarnings("unchecked") | |||
private ArrayBlockingQueue<Color> getColorHistory() { | |||
if (isAttached()) { | |||
Object colorHistory = getSession().getAttribute( | |||
"colorPickerHistory"); | |||
Object colorHistory = getSession() | |||
.getAttribute("colorPickerHistory"); | |||
if (colorHistory instanceof ArrayBlockingQueue<?>) { | |||
return (ArrayBlockingQueue<Color>) colorHistory; | |||
} | |||
@@ -135,7 +135,7 @@ public class ColorPickerHistory extends CustomComponent implements | |||
} | |||
} | |||
List<Color> colorList = new ArrayList<>(colorHistory); | |||
List<Color> colorList = new ArrayList<Color>(colorHistory); | |||
// Invert order of colors | |||
Collections.reverse(colorList); | |||
@@ -168,7 +168,7 @@ public class ColorPickerHistory extends CustomComponent implements | |||
/** | |||
* Gets the history. | |||
* | |||
* | |||
* @return the history | |||
*/ | |||
public List<Color> getHistory() { | |||
@@ -179,10 +179,10 @@ public class ColorPickerHistory extends CustomComponent implements | |||
/** | |||
* Checks if the history contains given color. | |||
* | |||
* | |||
* @param c | |||
* the color | |||
* | |||
* | |||
* @return true, if successful | |||
*/ | |||
public boolean hasColor(Color c) { | |||
@@ -191,7 +191,7 @@ public class ColorPickerHistory extends CustomComponent implements | |||
/** | |||
* Adds a color change listener | |||
* | |||
* | |||
* @param listener | |||
* The listener | |||
*/ | |||
@@ -202,7 +202,7 @@ public class ColorPickerHistory extends CustomComponent implements | |||
/** | |||
* Removes a color change listener | |||
* | |||
* | |||
* @param listener | |||
* The listener | |||
*/ |
@@ -133,7 +133,7 @@ public class ColorPickerPopup extends Window | |||
private ColorPickerSelect colorSelect; | |||
/** The selectors. */ | |||
private final Set<ColorSelector> selectors = new HashSet<>(); | |||
private final Set<ColorSelector> selectors = new HashSet<ColorSelector>(); | |||
/** | |||
* Set true while the slider values are updated after colorChange. When | |||
@@ -211,7 +211,7 @@ public class ColorPickerPopup extends Window | |||
history.setHeight("22px"); | |||
// Create the default colors | |||
List<Color> defaultColors = new ArrayList<>(); | |||
List<Color> defaultColors = new ArrayList<Color>(); | |||
defaultColors.add(Color.BLACK); | |||
defaultColors.add(Color.WHITE); | |||
@@ -19,7 +19,7 @@ public abstract class AbstractListenerMethodsTestBase { | |||
} | |||
private static void findAllListenerMethods() { | |||
Set<Class<?>> classes = new HashSet<>(); | |||
Set<Class<?>> classes = new HashSet<Class<?>>(); | |||
for (Class<?> c : VaadinClasses.getAllServerSideClasses()) { | |||
while (c != null && c.getName().startsWith("com.vaadin.")) { | |||
classes.add(c); |
@@ -17,7 +17,7 @@ import com.vaadin.v7.ui.Field; | |||
@SuppressWarnings("deprecation") | |||
public class VaadinClasses { | |||
private static final Set<String> WHITE_LIST_FQNS = new HashSet<>(); | |||
private static final Set<String> WHITE_LIST_FQNS = new HashSet<String>(); | |||
public static List<Class<? extends Field>> getFields() { | |||
return getServerClasses(Field.class::isAssignableFrom) |
@@ -34,7 +34,7 @@ public class SerializationTest { | |||
Form f = new Form(); | |||
String propertyId = "My property"; | |||
f.addItemProperty(propertyId, | |||
new MethodProperty<>(new Data(), "dummyGetterAndSetter")); | |||
new MethodProperty<Object>(new Data(), "dummyGetterAndSetter")); | |||
f.replaceWithSelect(propertyId, new Object[] { "a", "b", null }, | |||
new String[] { "Item a", "ITem b", "Null item" }); | |||
@@ -57,20 +57,22 @@ public class SerializationTest { | |||
@Test | |||
public void testMethodPropertyGetter() throws Exception { | |||
MethodProperty<?> mp = new MethodProperty<>(new Data(), "dummyGetter"); | |||
MethodProperty<?> mp = new MethodProperty<Object>(new Data(), | |||
"dummyGetter"); | |||
serializeAndDeserialize(mp); | |||
} | |||
@Test | |||
public void testMethodPropertyGetterAndSetter() throws Exception { | |||
MethodProperty<?> mp = new MethodProperty<>(new Data(), | |||
MethodProperty<?> mp = new MethodProperty<Object>(new Data(), | |||
"dummyGetterAndSetter"); | |||
serializeAndDeserialize(mp); | |||
} | |||
@Test | |||
public void testMethodPropertyInt() throws Exception { | |||
MethodProperty<?> mp = new MethodProperty<>(new Data(), "dummyInt"); | |||
MethodProperty<?> mp = new MethodProperty<Object>(new Data(), | |||
"dummyInt"); | |||
serializeAndDeserialize(mp); | |||
} | |||
@@ -279,7 +279,7 @@ public class ContainerDataSourceTest { | |||
// Use a container data source | |||
calendar.setEventProvider(new ContainerEventProvider( | |||
new BeanItemContainer<>(BasicEvent.class))); | |||
new BeanItemContainer<BasicEvent>(BasicEvent.class))); | |||
// Start and end dates to query for | |||
java.util.Calendar cal = java.util.Calendar.getInstance(); | |||
@@ -307,7 +307,7 @@ public class ContainerDataSourceTest { | |||
// Use a container data source | |||
calendar.setEventProvider(new ContainerEventProvider( | |||
new BeanItemContainer<>(BasicEvent.class))); | |||
new BeanItemContainer<BasicEvent>(BasicEvent.class))); | |||
// Start and end dates to query for | |||
java.util.Calendar cal = java.util.Calendar.getInstance(); | |||
@@ -366,7 +366,7 @@ public class ContainerDataSourceTest { | |||
@Test | |||
public void testAutomaticScaleVisibleHoursOfDay() { | |||
BeanItemContainer<CalendarEvent> container = new BeanItemContainer<>( | |||
BeanItemContainer<CalendarEvent> container = new BeanItemContainer<CalendarEvent>( | |||
CalendarEvent.class); | |||
java.util.Calendar start = java.util.Calendar.getInstance(); | |||
java.util.Calendar end = java.util.Calendar.getInstance(); | |||
@@ -416,7 +416,7 @@ public class ContainerDataSourceTest { | |||
} | |||
private static Indexed createTestBeanItemContainer() { | |||
BeanItemContainer<CalendarEvent> eventContainer = new BeanItemContainer<>( | |||
BeanItemContainer<CalendarEvent> eventContainer = new BeanItemContainer<CalendarEvent>( | |||
CalendarEvent.class); | |||
java.util.Calendar cal = java.util.Calendar.getInstance(); | |||
for (int i = 1; i <= 10; i++) { |
@@ -35,7 +35,7 @@ public class DateFieldConverterTest { | |||
@Before | |||
public void setUp() { | |||
date = new ObjectProperty<>(0L); | |||
date = new ObjectProperty<Long>(0L); | |||
datefield = new DateField(); | |||
datefield.setBuffered(false); | |||
datefield.setConverter(new Converter<Date, Long>() { |
@@ -81,7 +81,8 @@ public class FieldGroupTest { | |||
field2.setRequired(true); | |||
fieldGroup.bind(field2, "prop2"); | |||
Set<TextField> set = new HashSet<>(Arrays.asList(field1, field2)); | |||
Set<TextField> set = new HashSet<TextField>( | |||
Arrays.asList(field1, field2)); | |||
try { | |||
fieldGroup.commit(); |
@@ -1,12 +1,12 @@ | |||
/* | |||
* Copyright 2000-2016 Vaadin Ltd. | |||
* | |||
* | |||
* Licensed under the Apache License, Version 2.0 (the "License"); you may not | |||
* use this file except in compliance with the License. You may obtain a copy of | |||
* the License at | |||
* | |||
* | |||
* http://www.apache.org/licenses/LICENSE-2.0 | |||
* | |||
* | |||
* Unless required by applicable law or agreed to in writing, software | |||
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT | |||
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the | |||
@@ -59,8 +59,8 @@ public class GridEditorMissingPropertyTest { | |||
@Before | |||
public void setup() throws SecurityException, NoSuchMethodException { | |||
final BeanItem<Entry> folderItem = new BeanItem<>(folder); | |||
final BeanItem<Entry> childItem = new BeanItem<>(file); | |||
final BeanItem<Entry> folderItem = new BeanItem<Entry>(folder); | |||
final BeanItem<Entry> childItem = new BeanItem<Entry>(file); | |||
@SuppressWarnings("unchecked") | |||
TestContainer container = new TestContainer( | |||
@@ -252,7 +252,7 @@ public class GridEditorMissingPropertyTest { | |||
@Override | |||
protected List<Object> getAllItemIds() { | |||
List<Object> ids = new ArrayList<>(); | |||
List<Object> ids = new ArrayList<Object>(); | |||
for (BeanItem<Entry> item : items) { | |||
ids.add(item.getBean()); | |||
} |
@@ -27,7 +27,7 @@ public class ComboBoxValueChangeTest | |||
@Override | |||
protected void setValue(AbstractField<Object> field) { | |||
Map<String, Object> variables = new HashMap<>(); | |||
Map<String, Object> variables = new HashMap<String, Object>(); | |||
variables.put("selected", new String[] { "myvalue" }); | |||
((ComboBox) field).changeVariables(field, variables); | |||
} |
@@ -64,7 +64,7 @@ public class ComboBoxTest { | |||
private static void setFilterAndCurrentPage(ComboBox comboBox, | |||
String filterString, int currentPage) { | |||
Map<String, Object> variables = new HashMap<>(); | |||
Map<String, Object> variables = new HashMap<String, Object>(); | |||
variables.put("filter", filterString); | |||
variables.put("page", currentPage); | |||
comboBox.changeVariables(null, variables); |
@@ -56,7 +56,7 @@ public enum Resolution { | |||
*/ | |||
public static Iterable<Resolution> getResolutionsHigherOrEqualTo( | |||
Resolution r) { | |||
List<Resolution> resolutions = new ArrayList<>(); | |||
List<Resolution> resolutions = new ArrayList<Resolution>(); | |||
Resolution[] values = Resolution.values(); | |||
for (int i = r.ordinal(); i < values.length; i++) { | |||
resolutions.add(values[i]); | |||
@@ -74,7 +74,7 @@ public enum Resolution { | |||
* @return An iterable for the resolutions lower than r | |||
*/ | |||
public static List<Resolution> getResolutionsLowerThan(Resolution r) { | |||
List<Resolution> resolutions = new ArrayList<>(); | |||
List<Resolution> resolutions = new ArrayList<Resolution>(); | |||
Resolution[] values = Resolution.values(); | |||
for (int i = r.ordinal() - 1; i >= 0; i--) { | |||
resolutions.add(values[i]); |
@@ -143,7 +143,7 @@ public class GridState extends TabIndexState { | |||
/** | |||
* Column resize mode in grid. | |||
* | |||
* | |||
* @since 7.7.5 | |||
*/ | |||
public ColumnResizeMode columnResizeMode = ColumnResizeMode.ANIMATED; | |||
@@ -151,12 +151,12 @@ public class GridState extends TabIndexState { | |||
/** | |||
* Columns in grid. | |||
*/ | |||
public List<GridColumnState> columns = new ArrayList<>(); | |||
public List<GridColumnState> columns = new ArrayList<GridColumnState>(); | |||
/** | |||
* Column order in grid. | |||
*/ | |||
public List<String> columnOrder = new ArrayList<>(); | |||
public List<String> columnOrder = new ArrayList<String>(); | |||
public GridStaticSectionState header = new GridStaticSectionState(); | |||