<p>
A list of revisions.
</p>

@return A list of revisions.
320291
public java.util.List<ClusterDbRevision> getClusterDbRevisions() {
        if (clusterDbRevisions == null) {
            clusterDbRevisions = new com.amazonaws.internal.SdkInternalList<ClusterDbRevision>();
        }
        return clusterDbRevisions;
    }
1016184
public List<T> getAll() {
		List<T> result = new ArrayList<T>();
		if (nodes != null)
			for(Node element : nodes) 
				result.add(getCachedOrNewRepresentation(element));
		return result;
	}
	
	public int size() {
		return nodes.size();
	}
	
	public T get(int index) {
		return getCachedOrNewRepresentation(nodes.get(index));
	}
		
	public Iterator<T> iterator() {
		return getAll().iterator();
	}
}
82706
public Revision next()
		throws Exception
	{

		// Checks whether the next revision has already been reconstructed.
		Revision revision;
		if (chronoStorage.isTop(revisionIndex)) {

			// If this is the case the revision will removed from the storage
			return chronoStorage.remove();
		}

		// Otherwise the chronological order counter will be mapped to the
		// revsision counter
		int revCount = revisionIndex;
		if (mappingStorage.containsKey(revisionIndex)) {
			revCount = mappingStorage.get(revisionIndex);
		}

		// Retrieve the related full revision block
		ChronoFullRevision cfr = fullRevStorage.get(revCount);

		int queryPK, limit, previousRevisionCounter;
		String previousRevision;

		// Determine the nearest revision that could be used to construct
		// the specified revision
		revision = cfr.getNearest(revCount);
		if (revision == null) {

			// Create query bounds (all revisions from the full revision till
			// now)
			queryPK = articlePK + cfr.getStartRC() - 1;
			limit = revCount - cfr.getStartRC() + 1;

			previousRevision = null;
			previousRevisionCounter = -1;

		}
		else {

			// Create query bounds (only new revisions, last known + 1 till now)
			queryPK = revision.getPrimaryKey() + 1;
			limit = revCount - revision.getRevisionCounter();

			previousRevision = revision.getRevisionText();
			previousRevisionCounter = revision.getRevisionCounter();

		}

		Statement statement = null;
		ResultSet result = null;
		revision = null;

		try {
			statement = this.connection.createStatement();

			// Retrieve encoded revisions
			result = statement
					.executeQuery("SELECT Revision, PrimaryKey, RevisionCounter, RevisionID, ArticleID, Timestamp "
							+ "FROM revisions "
							+ "WHERE PrimaryKey >= "
							+ queryPK + " LIMIT " + limit);

			String currentRevision = null;

			Diff diff;
			RevisionDecoder decoder;

			boolean binaryData = result.getMetaData().getColumnType(1) == Types.LONGVARBINARY;

			while (result.next()) {

				decoder = new RevisionDecoder(config.getCharacterSet());

				// binary or base64 encoded
				if (binaryData) {
					decoder.setInput(result.getBinaryStream(1), true);
				}
				else {
					decoder.setInput(result.getString(1));
				}

				// Decode and rebuild
				diff = decoder.decode();
				if (previousRevisionCounter != -1) {

					if (previousRevisionCounter + 1 != result.getInt(3)) {

						System.err.println("Reconstruction data invalid - "
								+ "\r\n\t" + "Expected "
								+ (previousRevisionCounter + 1)
								+ " instead of " + result.getInt(3));

						return null;
					}

				}
				else {

					if (cfr.getStartRC() != result.getInt(3)) {

						System.err.println("Reconstruction data invalid - "
								+ "\r\n\t" + "Expected " + (cfr.getStartRC())
								+ " instead of " + result.getInt(3));

						return null;
					}

				}

				try {
					currentRevision = diff.buildRevision(previousRevision);

					revision = new Revision(result.getInt(3));
					revision.setRevisionText(currentRevision);
					revision.setPrimaryKey(result.getInt(2));
					revision.setRevisionID(result.getInt(4));
					revision.setArticleID(result.getInt(5));
					revision.setTimeStamp(new Timestamp(result.getLong(6)));

					previousRevision = currentRevision;
					previousRevisionCounter = revision.getRevisionCounter();

				}
				catch (Exception e) {

					System.err.println("Reconstruction failed while retrieving"
							+ " data to reconstruct <" + revisionIndex + ">"
							+ "\r\n\t" + "[ArticleId " + result.getInt(5)
							+ ", RevisionId " + result.getInt(4)
							+ ", RevisionCounter " + result.getInt(3) + "]");

					previousRevision = null;
					revision = null;

					return null;
				}

				// Add the reconstructed revision to the storage
				if (revision != null) {
					chronoStorage.add(revision);
				}
			}

			// Ensure that the correct revision is on top of the storage
			if (chronoStorage.isTop(revisionIndex)) {

				chronoStorage.remove();
				return revision;

			}
			else {
				return null;
			}

		}
		finally {
			if (statement != null) {
				statement.close();
			}
			if (result != null) {
				result.close();
			}
		}
	}
421642
@Override
    public List<RevisionInternal> getRevisionHistory(RevisionInternal rev) {
        Document doc = getDocument(rev.getDocID());
        if (doc == null)
            return null;
        try {
            try {
                if (!doc.selectRevID(rev.getRevID(), false))
                    return null;
            } catch (ForestException e) {
                Log.e(TAG, "Error in getRevisionHistory() rev=" + rev, e);
                return null;
            }
            List<RevisionInternal> history = new ArrayList<RevisionInternal>();
            do {
                RevisionInternal ancestor = ForestBridge.revisionObject(
                        doc, rev.getDocID(), null, false);
                if (ancestor == null)
                    break;
                ancestor.setMissing(!doc.hasRevisionBody());
                history.add(ancestor);
                // TODO: implement once ancestorRevIDs param is given.
                //if(ancestorRevIDs!=null&&ancestorRevIDs.contains(ancestor.getRevID()))
                //    break;
            } while (doc.selectParentRev());
            return history;
        } finally {
            doc.free();
        }
    }
470482
public java.util.List<Parameter> getParameterOverrides() {
        if (parameterOverrides == null) {
            parameterOverrides = new com.amazonaws.internal.SdkInternalList<Parameter>();
        }
        return parameterOverrides;
    }
968237
public java.util.List<String> getVersions() {
        if (versions == null) {
            versions = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return versions;
    }
1153909
public List<Object> getAll() {
		List<Object> components = new ArrayList<Object>();

		synchronized (_lock) {
			for (Reference reference : _references)
				components.add(reference.getComponent());
		}

		return components;
	}
540631
public java.util.List<Record> getRecords() {
        if (records == null) {
            records = new com.amazonaws.internal.SdkInternalList<Record>();
        }
        return records;
    }
839113
public void sortByDocID() {
        Collections.sort(this, new Comparator<RevisionInternal>() {
            public int compare(RevisionInternal rev1, RevisionInternal rev2) {
                return rev1.getDocID().compareTo(rev2.getDocID());
            }
        });
    }
1195378
public java.util.List<Setting> getSettings() {
        if (settings == null) {
            settings = new com.amazonaws.internal.SdkInternalList<Setting>();
        }
        return settings;
    }
1073122
public java.util.List<ModificationState> getModificationStates() {
        if (modificationStates == null) {
            modificationStates = new com.amazonaws.internal.SdkInternalList<ModificationState>();
        }
        return modificationStates;
    }
554273
public java.util.List<String> getReaders() {
        if (readers == null) {
            readers = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return readers;
    }
512129
public String[] list()
    {
        String[] list =_file.list();
        if (list==null)
            return null;
        for (int i=list.length;i-->0;)
        {
            if (new File(_file,list[i]).isDirectory() &&
                !list[i].endsWith("/"))
                list[i]+="/";
        }
        return list;
    }
524106
public java.util.List<String> getReplicasToRemove() {
        if (replicasToRemove == null) {
            replicasToRemove = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return replicasToRemove;
    }
247377
public java.util.List<StepSummary> getSteps() {
        if (steps == null) {
            steps = new com.amazonaws.internal.SdkInternalList<StepSummary>();
        }
        return steps;
    }
288293
public static List<CmsRelationType> getAll() {

        List<CmsRelationType> all = new ArrayList<CmsRelationType>(Arrays.asList(VALUE_ARRAY));
        all.addAll(OpenCms.getResourceManager().getRelationTypes());
        return Collections.unmodifiableList(all);
    }
325253
public List<E> toList()
    {
        ArrayList<E> list = new ArrayList<E>(queue.size());
        while (!queue.isEmpty())
        {
            list.add(0, queue.poll());
        }

        return list;
    }