Provides the scrollableList implementation for page scrolling
@return {@link LayoutScroller.ScrollableList} implementation, passed to {@link LayoutScroller}
for the processing the scrolling
555050
public LayoutScroller.ScrollableList getPageScrollable() {
        return new LayoutScroller.ScrollableList() {

            @Override
            public int getScrollingItemsCount() {
                return  MultiPageWidget.super.getScrollingItemsCount();
            }

            @Override
            public float getViewPortWidth() {
                return  MultiPageWidget.super.getViewPortWidth();
            }

            @Override
            public float getViewPortHeight() {
                return  MultiPageWidget.super.getViewPortHeight();
            }

            @Override
            public float getViewPortDepth() {
                return  MultiPageWidget.super.getViewPortDepth();
            }

            @Override
            public boolean scrollToPosition(int pos, final LayoutScroller.OnScrollListener listener) {
                return  MultiPageWidget.super.scrollToPosition(pos, listener);
            }

            @Override
            public boolean scrollByOffset(float xOffset, float yOffset, float zOffset,
                                          final LayoutScroller.OnScrollListener listener) {
                return  MultiPageWidget.super.scrollByOffset(xOffset, yOffset, zOffset, listener);
            }

            @Override
            public void registerDataSetObserver(DataSetObserver observer) {
                MultiPageWidget.super.registerDataSetObserver(observer);
            }

            @Override
            public void unregisterDataSetObserver(DataSetObserver observer) {
                MultiPageWidget.super.unregisterDataSetObserver(observer);
            }

            @Override
            public int getCurrentPosition() {
                return MultiPageWidget.super.getCurrentPosition();
            }

        };
    }
1140790
public LinearLayoutManager asVerticalListView() {
        this.presentation = PeasyPresentation.VerticalList;
        resetItemDecorations();
        resetItemAnimator();
        final LinearLayoutManager layoutManager = PeasyRecyclerView.VerticalList.newLayoutManager(getContext());
        getRecyclerView().setLayoutManager(layoutManager);
        getRecyclerView().addItemDecoration(new DividerItemDecoration(getContext(), layoutManager.getOrientation()));
        getRecyclerView().setItemAnimator(new DefaultItemAnimator());
        return layoutManager;
    }
489443
public List<LayoutProperty> getAllProperties() throws FetchException {
        List<LayoutProperty> all = mAllProperties;

        if (all == null) {
            Cursor <StoredLayoutProperty> cursor = mLayoutFactory.mPropertyStorage
                .query("layoutID = ?")
                .with(mStoredLayout.getLayoutID())
                .orderBy("ordinal")
                .fetch();

            try {
                List<LayoutProperty> list = new ArrayList<LayoutProperty>();

                while (cursor.hasNext()) {
                    list.add(new LayoutProperty(cursor.next()));
                }

                mAllProperties = all = Collections.unmodifiableList(list);
            } finally {
                cursor.close();
            }
        }

        return all;
    }
971300
private JScrollPane getJScrollPane() {
		if (jScrollPane == null) {
			jScrollPane = new JScrollPane();
			jScrollPane.setHorizontalScrollBarPolicy(javax.swing.JScrollPane.HORIZONTAL_SCROLLBAR_NEVER);
			jScrollPane.setVerticalScrollBarPolicy(javax.swing.JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED);
			jScrollPane.setViewportView(getTagList());
		}
		return jScrollPane;
	}
259329
public Map<Integer, String> getPageLinks() {

        Map<Integer, String> links = new TreeMap<Integer, String>();
        if (m_pageCount <= 1) {
            return links;
        }
        int startIndex, endIndex;
        String link = m_cms.getRequestContext().getUri() + m_parameters.toQueryString() + "&searchPage=";
        if (getDisplayPages() < 1) {
            // number of displayed pages not limited, build a map with all available page links
            startIndex = 1;
            endIndex = m_pageCount;
        } else {
            // limited number of displayed pages, calculate page range
            int currentPage = getSearchPage();
            int countBeforeCurrent = getDisplayPages() / 2;
            int countAfterCurrent;
            if ((currentPage - countBeforeCurrent) < 1) {
                // set count before to number of available pages
                countBeforeCurrent = currentPage - 1;
            }
            // set count after to number of remaining pages (- 1 for current page)
            countAfterCurrent = getDisplayPages() - countBeforeCurrent - 1;
            // calculate start and end index
            startIndex = currentPage - countBeforeCurrent;
            endIndex = currentPage + countAfterCurrent;
            // check end index
            if (endIndex > m_pageCount) {
                int delta = endIndex - m_pageCount;
                // decrease start index with delta to get the right number of displayed pages
                startIndex -= delta;
                // check start index to avoid values < 1
                if (startIndex < 1) {
                    startIndex = 1;
                }
                endIndex = m_pageCount;
            }
        }

        // build the sorted tree map of page links
        for (int i = startIndex; i <= endIndex; i++) {
            links.put(new Integer(i), (link + i));
        }
        return links;
    }
309672
public List<Row> getRowsCopy()
    {
        final List<Row> rows = new ArrayList<>(this.getRowsCount());

        for (Row cells : this)
        {
            rows.add(cells);
        }

        return rows;
    }
900501
public java.util.List<String> getAddRouteTableIds() {
        if (addRouteTableIds == null) {
            addRouteTableIds = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return addRouteTableIds;
    }
314702
public Iterable<HistoryPageEntry<T>> getRenderList() {
        if(trimmed) {
            List<HistoryPageEntry<T>> pageEntries = toPageEntries(baseList);
            if(pageEntries.size() > THRESHOLD) {
                return updateFirstTransientBuildKey(pageEntries.subList(0,THRESHOLD));
            } else {
                trimmed=false;
                return updateFirstTransientBuildKey(pageEntries);
            }
        } else {
                // to prevent baseList's concrete type from getting picked up by <j:forEach> in view
            return updateFirstTransientBuildKey(toPageEntries(baseList));
        }
    }
211872
protected List<CmsDialogElement> getElementList() {

        if (m_elementList == null) {
            m_elementList = CmsDialogElements.computeElements(getCms(), m_page, getParamTempfile(), getElementLocale());
        }
        return m_elementList;
    }
1318407
public List<ViewPropertyDescriptor> getApplicablePropertyDescriptors() {
        List<ViewPropertyDescriptor> r = new ArrayList<>();
        for (ViewPropertyDescriptor pd : ViewProperty.all()) {
            if (pd.isEnabledFor(this))
                r.add(pd);
        }
        return r;
    }
997681
@Nonnull
    public ImmutableList<T> toList() {
        return this.foldAbelian((v, acc) -> acc.cons(v), ImmutableList.empty());
    }
598531
public List list() {
        final Iterator iter = nodeIterator();
        final List result = new LinkedList();
        while (iter.hasNext()) {
            result.add(new NodeChild((Node) iter.next(), this.parent, this.namespacePrefix, this.namespaceTagHints));
        }
        return result;
    }
557138
@Nonnull
    public final LinkedList<A> toLinkedList() {
        LinkedList<A> list = new LinkedList<>();
        ImmutableList<A> l = this;
        for (int i = 0; i < length; i++) {
            list.add(((NonEmptyImmutableList<A>) l).head);
            l = ((NonEmptyImmutableList<A>) l).tail;
        }
        return list;
    }
836798
public List<T> toList() {
        final List<T> results = new ArrayList<T>();
        try {
            while (wrapped.hasNext()) {
                results.add(next());
            }
        } finally {
            wrapped.close();
        }
        return results;
    }
141764
public final void setScrollableArea(@NonNull final ScrollableArea scrollableArea) {
        Condition.INSTANCE.ensureNotNull(scrollableArea, "The scrollable area may not be null");
        this.scrollableArea = scrollableArea;
        addAreas();
    }
834031
public Iterator<QueryBinding> iterator() 
	{
		List<QueryBinding> iBindings = new ArrayList<QueryBinding>();
		for(QueryBindingImpl b : bindings) {
			iBindings.add(b);
		}
		return iBindings.iterator();
	}
239184
public List<Embeddable<EntityMappings<T>>> getAllEmbeddable()
   {
      List<Embeddable<EntityMappings<T>>> list = new ArrayList<Embeddable<EntityMappings<T>>>();
      List<Node> nodeList = childNode.get("embeddable");
      for(Node node: nodeList)
      {
         Embeddable<EntityMappings<T>>  type = new EmbeddableImpl<EntityMappings<T>>(this, "embeddable", childNode, node);
         list.add(type);
      }
      return list;
   }