Returns a list of subifds.

@return the subifds list
334958
public List<TiffObject> getIfdsAndSubIfds() {
    List<TiffObject> all = new ArrayList<TiffObject>();
    all.addAll(getMetadataList("IFD"));
    all.addAll(getMetadataList("SubIFDs"));
    return all;
  }
1229005
private List<String> getAllInitializers()
    {
        final List<String> ret = new ArrayList<>();
        for (final CacheMethod cacheMethod : this.cacheMethods) {
            ret.add(cacheMethod.className);
        }
        if (this.parent != null) {
            ret.addAll(this.parent.getAllInitializers());
        }
        return ret;
    }
661467
@Nonnull
  @ReturnsMutableCopy
  public ICommonsList <CSSSupportsRule> getAllSupportsRules ()
  {
    return m_aRules.getAllMapped (r -> r instanceof CSSSupportsRule, r -> (CSSSupportsRule) r);
  }
327491
protected List<String> parameters()
    {   
        List<String> cellsAsList = cellsAsList();
		return cellsAsList.subList(1, cellsAsList.size());
    }
247093
public List<TiffObject> getImageIfds() {
    List<TiffObject> l = new ArrayList<TiffObject>();
    IFD oifd = this.firstIFD;
    while (oifd != null) {
      if (oifd.isImage()) {
        if (oifd.hasSubIFD()) {
          try {
            long length = oifd.getMetadata().get("ImageLength").getFirstNumericValue();
            long width = oifd.getMetadata().get("ImageWidth").getFirstNumericValue();
            long sublength =
                oifd.getsubIFD().getMetadata().get("ImageLength").getFirstNumericValue();
            long subwidth = oifd.getsubIFD().getMetadata().get("ImageWidth").getFirstNumericValue();
            if (sublength > length && subwidth > width) {
              l.add(oifd.getsubIFD());
            } else {
              l.add(oifd);
            }
          } catch (Exception ex) {
            l.add(oifd);
          }
        } else {
          l.add(oifd);
        }
      }
      oifd = oifd.getNextIFD();
    }
    return l;
  }
631962
@Override
	public List<V> subList(final int fromIndex, final int toIndex) {
		return this.list.subList(fromIndex, toIndex);
	}
376689
private List<Integer> getSubPicturesToBeExported() {
		List<Integer> subPicturesToBeExported = new ArrayList<Integer>();
		for (int i = 0; i < subPictures.length; i++) {
			SubPicture subPicture = subPictures[i];
			if (!subPicture.isExcluded()
					&& (!configuration.isExportForced() || subPicture
							.isForced())) {
				subPicturesToBeExported.add(i);
			}
		}
		return subPicturesToBeExported;
	}
944628
public List<String> getChainIds() {

		List<String> chains = new ArrayList<String>(getSubunitCount());

		// Loop through all subunits in the clusters and fill Lists
		for (int c = 0; c < clusters.size(); c++) {
			for (int s = 0; s < clusters.get(c).size(); s++)
				chains.add(clusters.get(c).getSubunits().get(s).getName());
		}

		return chains;
	}

	/**
	 * This method is provisional and should only be used for coloring Subunits.
	 * A new coloring schema has to be implemented to allow the coloring of
	 * Subunits, without implying one Subunit = one Chain.
	 *
	 * @return A List of the Model number of each Subunit
	 */
	public List<Integer> getModelNumbers() {

		List<Integer> models = new ArrayList<Integer>(getSubunitCount());

		// Loop through all subunits in the clusters and fill Lists
		for (int c = 0; c < clusters.size(); c++) {
			for (int s = 0; s < clusters.get(c).size(); s++) {

				Atom[] atoms = clusters.get(c).getAlignedAtomsSubunit(s);

				// TODO guess them chain and model (very ugly)
				Chain chain = atoms[0].getGroup().getChain();

				int model = 0;
				for (int m = 0; m < chain.getStructure().nrModels(); m++) {
					if (chain.getStructure().getModel(m).contains(chain)) {
						model = m;
						break;
					}
				}
				models.add(model);
			}
		}
		return models;
	}

	public int getSubunitCount() {
		run();
		if (centers == null) {
			return 0;
		}
		return centers.size();
	}

	public List<Integer> getFolds() {
		return folds;
	}

	public int getCalphaCount() {
		int count = 0;
		for (Point3d[] trace : caCoords) {
			count += trace.length;
		}
		return count;
	}

	public int getLargestSubunit() {
		int index = -1;
		int maxLength = 0;
		for (int i = 0; i < caCoords.size(); i++) {
			int length = caCoords.get(i).length;
			if (length > maxLength) {
				index = i;
			}
		}
		return index;
	}

	public List<Point3d> getCenters() {
		run();
		return centers;
	}

	public List<Vector3d> getUnitVectors() {
		run();
		return unitVectors;
	}

	public List<Point3d> getOriginalCenters() {
		run();
		return originalCenters;
	}

	public Point3d getCentroid() {
		run();
		return centroid;
	}

	public MomentsOfInertia getMomentsOfInertia() {
		run();
		return momentsOfInertia;
	}

	private void run() {
		if (centers.size() > 0) {
			return;
		}
		calcOriginalCenters();
		calcCentroid();
		calcCenters();
		calcMomentsOfIntertia();
	}

	private void calcOriginalCenters() {
		for (Point3d[] trace : caCoords) {
			Point3d com = CalcPoint.centroid(trace);
			originalCenters.add(com);
		}
	}

	private void calcCentroid() {
		Point3d[] orig = originalCenters.toArray(new Point3d[originalCenters
				.size()]);
		centroid = CalcPoint.centroid(orig);
	}

	private void calcCenters() {
		for (Point3d p : originalCenters) {
			Point3d c = new Point3d(p);
			c.sub(centroid);
			centers.add(c);
			Vector3d v = new Vector3d(c);
			v.normalize();
			unitVectors.add(v);
		}
	}

	public Point3d getLowerBound() {
		Point3d lower = new Point3d();
		for (Point3d p : centers) {
			if (p.x < lower.x) {
				lower.x = p.x;
			}
			if (p.y < lower.y) {
				lower.y = p.y;
			}
			if (p.z < lower.z) {
				lower.z = p.z;
			}
		}
		return lower;
	}

	public Point3d getUpperBound() {
		Point3d upper = new Point3d();
		for (Point3d p : centers) {
			if (p.x > upper.x) {
				upper.x = p.x;
			}
			if (p.y > upper.y) {
				upper.y = p.y;
			}
			if (p.z > upper.z) {
				upper.z = p.z;
			}
		}
		return upper;
	}

	private void calcMomentsOfIntertia() {
		for (Point3d[] trace : caCoords) {
			for (Point3d p : trace) {
				momentsOfInertia.addPoint(p, 1.0f);
			}
		}
	}

}
1270403
public List<String> getSubscriptionList() throws SIResourceException
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(tc, "getSubscriptionList");
        List<String> subscriptions = null;

        // Build up a list of subscriptions on the destination
        try
        {
            NonLockingCursor cursor =
                            _pubsubMessageItemStream.newNonLockingReferenceStreamCursor(
                                            new ClassEqualsFilter(
                                                            SubscriptionItemStream.class,
                                                            DurableSubscriptionItemStream.class));
            SubscriptionItemStream subscription =
                            (SubscriptionItemStream) cursor.next();

            while (subscription != null)
            {
                if (subscriptions == null)
                {
                    subscriptions = new LinkedList<String>();
                }
                subscriptions.add(
                                subscription
                                                .getConsumerDispatcher()
                                                .getConsumerDispatcherState()
                                                .getSubscriberID());
                subscription = (SubscriptionItemStream) cursor.next();
            }

            cursor.finished();
        } catch (MessageStoreException e)
        {
            FFDCFilter.processException(
                                        e,
                                        "com.ibm.ws.sib.processor.impl.destination.PubSubRealization.getSubscriptionList",
                                        "1:2579:1.35.2.4",
                                        this);

            SibTr.exception(tc, e);
            if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
                SibTr.exit(tc, "getSubscriptionList", "SIResourceException");
            throw new SIResourceException(e);
        }
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(tc, "getSubscriptionList", subscriptions);
        return subscriptions;
    }
683103
public List<ElementSubSet<E>> getPartitions() {
        final List<ElementSubSet<E>> partitions = new ArrayList<>();
        forEachPartition((idx, key, from, to) -> {
            partitions.add(new ElementSubSet<>(SplittableElementSet.this, key, from, to));
            return true;
        });
        return partitions;
    }
1201614
public java.util.List<String> getLayerIds() {
        if (layerIds == null) {
            layerIds = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return layerIds;
    }
374741
public List<Index<SecondaryTable<T>>> getAllIndex()
   {
      List<Index<SecondaryTable<T>>> list = new ArrayList<Index<SecondaryTable<T>>>();
      List<Node> nodeList = childNode.get("index");
      for(Node node: nodeList)
      {
         Index<SecondaryTable<T>>  type = new IndexImpl<SecondaryTable<T>>(this, "index", childNode, node);
         list.add(type);
      }
      return list;
   }
1208336
public List<N> getConnectedComponents() {
        setMarkedAllNodes(false);
        ArrayList<N> roots = new ArrayList<N>();
        //for (int i=0; i<nodes.size(); i++) {
        for (N n : nodes) {
            if (!n.isMarked()) {
                roots.add(n);
                dfs(n);
            }
        }
        return roots;
    }
1186008
public List<SupportsType<PortletType<T>>> getAllSupports()
   {
      List<SupportsType<PortletType<T>>> list = new ArrayList<SupportsType<PortletType<T>>>();
      List<Node> nodeList = childNode.get("supports");
      for(Node node: nodeList)
      {
         SupportsType<PortletType<T>>  type = new SupportsTypeImpl<PortletType<T>>(this, "supports", childNode, node);
         list.add(type);
      }
      return list;
   }
114743
public List<Node> siblingNodes() {
        if (parentNode == null)
            return Collections.emptyList();

        List<Node> nodes = parentNode.ensureChildNodes();
        List<Node> siblings = new ArrayList<>(nodes.size() - 1);
        for (Node node: nodes)
            if (node != this)
                siblings.add(node);
        return siblings;
    }
584231
public InstantConverter[] getInstantConverters() {
        ConverterSet set = iInstantConverters;
        InstantConverter[] converters = new InstantConverter[set.size()];
        set.copyInto(converters);
        return converters;
    }
1262669
public List<Table> asTableList() {
        List<Table> tableList = new ArrayList<>();
        for (TableSlice view : this) {
            tableList.add(view.asTable());
        }
        return tableList;
    }