public int getAvailableRows() { if (!availableRowsCached) { availableRows = delegate.getAvailableRows(); availableRowsCached = true; } return availableRows; }
/** * Return whether the data source is empty, i.e. does not have any rows available. */ default public boolean isEmpty() { return getAvailableRows(1) == 0; }
public int getAvailableRows() { if (!availableRowsCached) { availableRows = delegate.getAvailableRows(); availableRowsCached = true; if (availableRows == 0) { empty = true; emptyCached = true; } else { empty = false; emptyCached = true; } } return availableRows; }
/** * Return the number of rows available in the data source with an upper limit. * If determining the total number of rows is expensive, this method should be overridden to provide a more * efficient implementation. * Please note that the default Grid pager will still determine the total number of rows, so for this to have * an effect, a custom pager should be used. * * @param limit the upper limit * @return the number of rows or {@code limit}, whichever is lower */ default public int getAvailableRows(final int limit) { int availableRows = getAvailableRows(); if (availableRows >= limit) { return limit; } return availableRows; }
@Override public int getAvailableRows(int limit) { if (!availableRowsCached) { int result = delegate.getAvailableRows(limit); if (result == 0) { empty = true; emptyCached = true; } else { empty = false; emptyCached = true; } if (result < limit) { availableRows = result; availableRowsCached = true; } return result; } else { return Math.min(availableRows, limit); } }
void setupRender() { GridDataSource dataSource = gridModel.getDataSource(); int numberOfRowsRequiredToShowCurrentPage = 1 + (currentPage - 1) * rowsPerPage; int numberOfRowsRequiredToFillCurrentPage = currentPage * rowsPerPage; int availableRowsWithLimit = dataSource.getAvailableRows(numberOfRowsRequiredToFillCurrentPage); // This can sometimes happen when the number of items shifts between requests. if (numberOfRowsRequiredToShowCurrentPage > availableRowsWithLimit) { int maxPages = ((availableRowsWithLimit - 1) / rowsPerPage) + 1; currentPage = maxPages; } startRow = (currentPage - 1) * rowsPerPage; endRow = Math.min(availableRowsWithLimit - 1, startRow + rowsPerPage - 1); dataRowIndex = startRow; boolean recordingStateInsideForm = !volatileState && formSupport != null; recordStateByIndex = recordingStateInsideForm && (encoder == null); recordStateByEncoder = recordingStateInsideForm && (encoder != null); }
public CustomGridDataSource(GridDataSource gds) { super(); this.datas = new ArrayList<Object>(); for(int i = 0; i < gds.getAvailableRows(); i++){ datas.add(gds.getRowValue(i)); } this.cgds = new CollectionGridDataSource(datas); }
void setupDataSource() { // TAP5-34: We pass the source into the CachingDataSource now; previously // we were accessing source directly, but during submit the value wasn't // cached, and therefore access was very inefficient, and sorting was // very inconsistent during the processing of the form submission. int effectiveCurrentPage = getCurrentPage(); int numberOfRowsRequiredToShowCurrentPage = 1 + (effectiveCurrentPage - 1) * rowsPerPage; int numberOfRowsRequiredToFillCurrentPage = effectiveCurrentPage * rowsPerPage; cachingSource = new CachingDataSource(source); if (pagerPosition != GridPagerPosition.NONE) { // We're going to render the pager, so we need to determine the total number of rows anyway. // We do that eagerly here so we don't have to perform two count operations; the subsequent // ones will return a cached result cachingSource.getAvailableRows(); } int availableRowsWithLimit = cachingSource.getAvailableRows(numberOfRowsRequiredToFillCurrentPage); if (availableRowsWithLimit == 0) return; // This captures when the number of rows has decreased, typically due to deletions. if (numberOfRowsRequiredToShowCurrentPage > availableRowsWithLimit) { int maxPage = ((availableRowsWithLimit - 1) / rowsPerPage) + 1; effectiveCurrentPage = maxPage; } int startIndex = (effectiveCurrentPage - 1) * rowsPerPage; int endIndex = Math.min(startIndex + rowsPerPage - 1, availableRowsWithLimit - 1); cachingSource.prepare(startIndex, endIndex, sortModel.getSortConstraints()); }
/** * This method will filter all your data by using the search input from your datatable. */ public GridDataSource filterData(GridDataSource source){ final List<Object> datas = new ArrayList<Object>(); for(int index=0;index<source.getAvailableRows();index++){ boolean flag = false; for (Object name: model.getPropertyNames()) { PropertyConduit conduit = model.get((String) name).getConduit(); try{ String val = (String) conduit.get(source.getRowValue(index)); if(val.contains(request.getParameter(DataTableConstants.SEARCH))) flag = true; } catch (Exception e){ } } if(flag){ datas.add(source.getRowValue(index)); } } return new CustomGridDataSource(datas); }
/** * Iterator for the look component in order to loop to each rows */ public Iterable<Integer> getLoopSource() { // Issue #284 : call prepared() before calling getRowValue() int startIndex = 0; int endIndex = getSource().getAvailableRows() - 1; getSource().prepare(startIndex, endIndex, sortModel.getSortConstraints()); return new Iterable<Integer>() { public Iterator<Integer> iterator() { return new Iterator<Integer>() { Integer i = new Integer(0); public boolean hasNext() { return i < getSource().getAvailableRows(); } public Integer next() { row = getSource().getRowValue(i); return i++; } public void remove() { i = 0; } }; } }; }
void beginRender(MarkupWriter writer) int availableRows = source.getAvailableRows();
final int records = source.getAvailableRows();