Example usage for org.apache.wicket.markup.repeater IItemFactory newItem

Introduction

In this page you can find the example usage for org.apache.wicket.markup.repeater IItemFactory newItem.

Prototype

Item<T> newItem(final int index, final IModel<T> model);

Source Link

Document

Factory method for instances of Item.

Usage

From source file:com.aplombee.AbstractItemsNavigationStrategy.java

License:Apache License

/**
 * @inheritDoc//  w w w .  j  a va 2s.c  om
 */
@Override
public <T> Iterator<Item<T>> addItems(int startIndex, IItemFactory<T> factory, Iterator<IModel<T>> newModels) {
    int itemIndex = startIndex;
    List<Item<T>> components = new ArrayList<Item<T>>();
    for (; newModels.hasNext(); itemIndex++) {
        IModel<T> newModel = newModels.next();
        Item<T> item = factory.newItem(itemIndex, newModel);
        components.add(item);
    }

    return components.iterator();
}

---

From source file:com.aplombee.AbstractItemsNavigationStrategyTest.java

License:Apache License

public void assertAddItems(IQuickReuseStrategy strategy) {
    IModel model1 = Mockito.mock(IModel.class);
    IModel model2 = Mockito.mock(IModel.class);
    Iterator newModels = Mockito.mock(Iterator.class);
    Mockito.when(newModels.next()).thenReturn(model1).thenReturn(model2);
    Mockito.when(newModels.hasNext()).thenReturn(true).thenReturn(true).thenReturn(false);
    IItemFactory factory = Mockito.mock(IItemFactory.class);
    final int startIndex = 345;
    final int index2 = startIndex + 1;
    Item item1 = new Item("345", startIndex, model1);
    Mockito.when(factory.newItem(startIndex, model1)).thenReturn(item1);
    Item item2 = new Item("346", index2, model2);
    Mockito.when(factory.newItem(index2, model2)).thenReturn(item2);

    Iterator<Item> actual = strategy.addItems(startIndex, factory, newModels);
    Mockito.verify(factory, Mockito.times(1)).newItem(startIndex, model1);
    Mockito.verify(factory, Mockito.times(1)).newItem(index2, model2);
    Assert.assertEquals(actual.next(), item1);
    Assert.assertEquals(actual.next(), item2);
    Assert.assertFalse(actual.hasNext());

}

---

From source file:com.aplombee.DefaultQuickReuseStrategyTest.java

License:Apache License

/**
 * existing items empty/*from w  ww. j  a v a 2  s .com*/
 */
@Test(groups = { "wicketTests" })
public void getItems_1() {
    IQuickReuseStrategy strategy = new DefaultQuickReuseStrategy();
    List<Integer> list = new ArrayList<Integer>();
    list.add(45);
    list.add(76);
    List<Item<Integer>> existingItems = new ArrayList<Item<Integer>>();
    IItemFactory factory = Mockito.mock(IItemFactory.class);
    final int index = 0;
    final int index2 = 1;
    IModel<Integer> model1 = new Model<Integer>(list.get(0));
    IModel<Integer> model2 = new Model<Integer>(list.get(1));
    Item item1 = new Item("0", 0, model1);
    Mockito.when(factory.newItem(0, model1)).thenReturn(item1);
    Item item2 = new Item("1", index2, model2);
    Mockito.when(factory.newItem(index2, model2)).thenReturn(item2);
    List<IModel<Integer>> newModels = new ArrayList<IModel<Integer>>();
    newModels.add(model1);
    newModels.add(model2);

    Iterator<Item<Integer>> actual = strategy.getItems(factory, newModels.iterator(), existingItems.iterator());
    Assert.assertEquals(actual.next(), item1);
    Assert.assertEquals(actual.next(), item2);
    Mockito.verify(factory, Mockito.times(1)).newItem(index, model1);
    Mockito.verify(factory, Mockito.times(1)).newItem(index2, model2);

}

---

From source file:com.aplombee.ItemsNavigationStrategyTest.java

License:Apache License

@Test(groups = { "wicketTests" })
public void getItems_1() {
    IQuickReuseStrategy strategy = new ItemsNavigationStrategy();
    List<Integer> list = new ArrayList<Integer>();
    list.add(45);/*from   w  ww. j ava2 s  .  co m*/
    list.add(76);

    IItemFactory factory = Mockito.mock(IItemFactory.class);
    final int index = 0;
    final int index2 = 1;
    IModel<Integer> model1 = new Model<Integer>(list.get(0));
    IModel<Integer> model2 = new Model<Integer>(list.get(1));
    Item item1 = new Item("0", 0, model1);
    Mockito.when(factory.newItem(0, model1)).thenReturn(item1);
    Item item2 = new Item("1", index2, model2);
    Mockito.when(factory.newItem(index2, model2)).thenReturn(item2);
    List<IModel<Integer>> newModels = new ArrayList<IModel<Integer>>();
    newModels.add(model1);
    newModels.add(model2);

    Iterator<Item<Integer>> actual = strategy.getItems(factory, newModels.iterator(), null);
    Assert.assertEquals(actual.next(), item1);
    Assert.assertEquals(actual.next(), item2);

}

---

From source file:com.aplombee.QuickViewTest.java

License:Apache License

/**
 * page=2 ,itemsperrequest=2 ,reuse=ReUse.ITEMSNAVIGATION
 *///from   ww w .  j a  v  a  2s. co  m

@Test(groups = { "wicketTests" })
public void addItemsForPage_1() {
    int itemsPerRequest = 2;
    IDataProvider dataProvider = Mockito.mock(IDataProvider.class);
    Iterator data = mockIterator();
    Mockito.when(dataProvider.iterator(4, itemsPerRequest)).thenReturn(data);
    Mockito.when(data.hasNext()).thenReturn(true).thenReturn(true).thenReturn(false);
    IModel<Integer> model1 = new Model<Integer>(11);
    IModel<Integer> model2 = new Model<Integer>(55);

    final Iterator<IModel<Integer>> newModels = Mockito.mock(Iterator.class);
    Mockito.when(newModels.next()).thenReturn(model1);
    Mockito.when(newModels.next()).thenReturn(model2);
    Mockito.when(newModels.hasNext()).thenReturn(true).thenReturn(true).thenReturn(false);
    Item<Integer> item1 = new Item("1", 1, model1);
    Item<Integer> item2 = new Item("2", 2, model2);
    List<Item<Integer>> list = new ArrayList<Item<Integer>>();
    list.add(item1);
    list.add(item2);
    final Iterator newIterator = list.iterator();
    final IQuickReuseStrategy reuseStrategy = Mockito.mock(IQuickReuseStrategy.class);
    final IItemFactory factory = Mockito.mock(IItemFactory.class);
    Mockito.when(factory.newItem(1, model1)).thenReturn(item1);
    Mockito.when(factory.newItem(2, model2)).thenReturn(item2);
    Mockito.when(reuseStrategy.addItems(4, factory, newModels)).thenReturn(list.iterator());
    QuickView repeater = new QuickView("repeater", dataProvider, new ItemsNavigationStrategy(),
            itemsPerRequest) {

        public void populate(Item item) {
        }

        @Override
        public MarkupContainer add(Component... c) {
            return this;
        }

        @Override
        protected Iterator buildItems(long index, Iterator iterator) {
            return newIterator;
        }

        @Override
        protected Iterator newModels(long offset, long count) {
            return newModels;
        }

        @Override
        public IItemFactory factory() {
            return factory;
        }
    };
    repeater.setReuseStrategy(reuseStrategy);
    QuickView spy = Mockito.spy(repeater);
    List<Item<TestObj>> items = spy.addItemsForPage(2);
    Mockito.verify(reuseStrategy, Mockito.times(1)).addItems(4, factory, newModels);

    Assert.assertEquals(items.size(), list.size());
    Mockito.verify(spy, Mockito.times(1)).add(items.get(0));
    Mockito.verify(spy, Mockito.times(1)).add(items.get(1));

}

---

From source file:com.aplombee.ReuseAllStrategy.java

License:Apache License

/**
 * reuseas all the existing items by returning iterator over existing items after copying them
 *
 * @param <T>/*  ww w .ja va2s .  c o  m*/
 *            type of Item
 *
 * @param factory
 *            implementation of IItemFactory
 * @param newModels
 *            iterator over models for items
 * @param existingItems
 *            iterator over child items
 * @return iterator over exisiting items
 */
@Override
public <T> Iterator<Item<T>> getItems(IItemFactory<T> factory, Iterator<IModel<T>> newModels,
        Iterator<Item<T>> existingItems) {
    List<Item<T>> copy = new ArrayList<Item<T>>();
    while (existingItems.hasNext()) {
        copy.add(existingItems.next());
    }
    if (!copy.isEmpty()) {
        return copy.iterator();
    }

    for (int index = 0; newModels.hasNext(); index++) {
        IModel<T> model = newModels.next();
        Item<T> item = factory.newItem(index, model);
        copy.add(item);
    }

    return copy.iterator();
}

---

From source file:com.aplombee.ReuseAllStrategyTest.java

License:Apache License

/**
 * existing items empty//from   ww w .  ja v  a 2  s.co  m
 */
@Test(groups = { "wicketTests" })
public void getItems_1() {
    IQuickReuseStrategy strategy = new ReuseAllStrategy();
    List<Integer> list = new ArrayList<Integer>();
    list.add(45);
    list.add(76);
    List<Item<Integer>> existingItems = new ArrayList<Item<Integer>>();
    IItemFactory factory = Mockito.mock(IItemFactory.class);
    final int index = 0;
    final int index2 = 1;
    IModel<Integer> model1 = new Model<Integer>(list.get(0));
    IModel<Integer> model2 = new Model<Integer>(list.get(1));
    Item item1 = new Item("0", 0, model1);
    Mockito.when(factory.newItem(0, model1)).thenReturn(item1);
    Item item2 = new Item("1", index2, model2);
    Mockito.when(factory.newItem(index2, model2)).thenReturn(item2);
    List<IModel<Integer>> newModels = new ArrayList<IModel<Integer>>();
    newModels.add(model1);
    newModels.add(model2);

    Iterator<Item<Integer>> actual = strategy.getItems(factory, newModels.iterator(), existingItems.iterator());
    Assert.assertEquals(actual.next(), item1);
    Assert.assertEquals(actual.next(), item2);
    Mockito.verify(factory, Mockito.times(1)).newItem(index, model1);
    Mockito.verify(factory, Mockito.times(1)).newItem(index2, model2);

}

---

From source file:org.artifactory.common.wicket.component.table.groupable.GroupedItemsStrategy.java

License:Open Source License

@Override
public <T> Iterator<Item<T>> getItems(final IItemFactory<T> factory, final Iterator<IModel<T>> newModels,
        Iterator<Item<T>> existingItems) {
    return new Iterator<Item<T>>() {
        private int index = 0;

        private Object lastGroupValue;
        private Item<T> lastGroupItem;
        private IModel<T> lastGroupModel;

        @Override//ww w  . ja  va  2s  . c  om
        public void remove() {
            throw new UnsupportedOperationException();
        }

        @Override
        public boolean hasNext() {
            return lastGroupModel != null || newModels.hasNext();
        }

        @Override
        @SuppressWarnings({ "unchecked" })
        public Item<T> next() {
            // returned group item in last iteration, return saved model item
            if (lastGroupModel != null) {
                Item<T> item = newRowItem(lastGroupModel);
                lastGroupModel = null;
                return item;
            }

            IModel<T> model = newModels.next();
            GroupableDataProvider provider = table.getGroupableDataProvider();
            SortParam groupParam = provider.getGroupParam();
            if (groupParam != null && model != null) {
                String property = groupParam.getProperty();
                IChoiceRenderer renderer = provider.getGroupRenderer(property);
                T modelObject = model.getObject();
                Object value = renderer.getIdValue(modelObject, index);
                if (!value.equals(lastGroupValue)) {
                    lastGroupValue = value;
                    lastGroupModel = model;
                    GroupableTable modificationTable = (GroupableTable) SerializationUtils.clone(table);
                    lastGroupItem = modificationTable.newGroupRowItem("group" + index, index, model);
                    Item cellItem = modificationTable.newGroupCellItem("cells", 0, model);
                    lastGroupItem.add(cellItem);
                    modificationTable.populateGroupItem(cellItem, "cell", property, model);
                    return lastGroupItem;
                }
            }
            return newRowItem(model);
        }

        @SuppressWarnings({ "unchecked" })
        private Item<T> newRowItem(IModel<T> model) {
            Item<T> item = factory.newItem(index, model);
            if (lastGroupItem != null && !table.isGroupExpanded(lastGroupItem)
                    && table.getGroupableDataProvider().getGroupParam() != null) {
                item.add(new CssClass("row-collapsed"));
            }
            index++;
            return item;
        }
    };
}

---

From source file:org.opensingular.form.wicket.repeater.PathInstanceItemReuseStrategy.java

License:Apache License

@Override
public <T> Iterator<Item<T>> getItems(IItemFactory<T> factory, Iterator<IModel<T>> newModels,
        Iterator<Item<T>> existingItems) {

    final Map<String, Item<T>> pathAndItem = buildExisistingItensPathAndItemMap(existingItems);

    return new Iterator<Item<T>>() {

        private int index = 0;

        @Override//from www  . j  a  va2s .  c  o  m
        public boolean hasNext() {
            return newModels.hasNext();
        }

        @Override
        public Item<T> next() {
            index += 1;

            final IModel<T> next = newModels.next();
            final Optional<String> path = getPath(next);

            if (path.isPresent() && pathAndItem.containsKey(path.get())) {
                return pathAndItem.get(path.get());
            } else {
                return factory.newItem(index, next);
            }
        }
    };
}

---