Returns an Iterator for looping over all isotopes in this MolecularFormulaExpand.

@return    An Iterator with the isotopes in this MolecularFormulaExpand
507805
public Iterable<IIsotope> isotopes() {
        return new Iterable<IIsotope>() {

            @Override
            public Iterator<IIsotope> iterator() {
                return isotopesMax.keySet().iterator();
            }
        };
    }
670642
public Iterator<T> iterator() {
        List<Iterator<T>> iters = new ArrayList<Iterator<T>>(sets.size());
        for (Set<T> s : sets)
            iters.add(s.iterator());
        return new CombinedIterator<T>(iters);
    }
317844
public IsotopePattern getIsotopes(IMolecularFormula molFor) {

        if (builder == null) {
            try {
                isoFactory = Isotopes.getInstance();
                builder = molFor.getBuilder();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        String mf = MolecularFormulaManipulator.getString(molFor, true);

        IMolecularFormula molecularFormula = MolecularFormulaManipulator.getMajorIsotopeMolecularFormula(mf, builder);

        IsotopePattern abundance_Mass = null;

        for (IIsotope isos : molecularFormula.isotopes()) {
            String elementSymbol = isos.getSymbol();
            int atomCount = molecularFormula.getIsotopeCount(isos);

            // Generate possible isotope containers for the current atom's
            // these will then me 'multiplied' with the existing patten
            List<IsotopeContainer> additional = new ArrayList<>();
            for (IIsotope isotope : isoFactory.getIsotopes(elementSymbol)) {
                double mass      = isotope.getExactMass();
                double abundance = isotope.getNaturalAbundance();
                if (abundance <= 0.000000001)
                    continue;
                IsotopeContainer container = new IsotopeContainer(mass, abundance);
                if (storeFormula)
                    container.setFormula(asFormula(isotope));
                additional.add(container);
            }

            for (int i = 0; i < atomCount; i++)
                abundance_Mass = calculateAbundanceAndMass(abundance_Mass, additional);
        }

        IsotopePattern isoP = IsotopePatternManipulator.sortAndNormalizedByIntensity(abundance_Mass);
        isoP = cleanAbundance(isoP, minIntensity);
        IsotopePattern isoPattern = IsotopePatternManipulator.sortByMass(isoP);
        return isoPattern;

    }
314121
public Iterator<QueryParameters> iterator() {
        final QueryParametersLazyList source = this;

        return new Iterator<QueryParameters>() {
            private LazyCacheIterator<QueryParameters> lazyCacheIterator = source.getLazyCacheIterator(-1);

            public boolean hasNext() {
                return lazyCacheIterator.hasNext();
            }

            public QueryParameters next() {
                return lazyCacheIterator.getNext();
            }

            public void remove() {
                source.remove(currentIndex);
            }
        };
    }
312629
public Iterator<Long> iterator() {
    final LongIterator it = getLongIterator();

    return new Iterator<Long>() {

      @Override
      public boolean hasNext() {
        return it.hasNext();
      }

      @Override
      public Long next() {
        return it.next();
      }

      @Override
      public void remove() {
        // TODO?
        throw new UnsupportedOperationException();
      }
    };
  }
469138
private IIsotope getIsotope(IIsotope isotope) {
        for (Iterator<IIsotope> it = isotopes().iterator(); it.hasNext();) {
            IIsotope thisIsotope = it.next();
            if (isTheSame(isotope, thisIsotope)) return thisIsotope;
        }
        return null;
    }
278307
@Override
   public Iterator<TopologyElementCalled> iterator() {
      Iterator<TopologyElementCalled> it = new Iterator<TopologyElementCalled>() {

         int currentIndex = 0;

         @Override
         public boolean hasNext() {
            return currentIndex < dependences.size();

         }

         @Override
         public TopologyElementCalled next() {
            TopologyElementCalled currentEl = dependences.get(currentIndex);
            currentIndex++;
            return currentEl;
         }

         @Override
         public void remove() {

         }
      };
      return it;
   }
195926
@Override
    public Iterable<IChemSequence> chemSequences() {
        return new Iterable<IChemSequence>() {

            @Override
            public Iterator<IChemSequence> iterator() {
                return new ChemSequenceIterator();
            }
        };
    }
97632
public Iterator iterator()
   {
      if (tc.isEntryEnabled()) SibTr.entry(tc, "iterator");
      if (tc.isEntryEnabled()) SibTr.exit(tc, "iterator");

      return map.values().iterator();
   }
837481
public Iterator<R> iterator() {
        return new Iterator<R>() {
            R last = null;
            R next = newestBuild();

            public boolean hasNext() {
                return next!=null;
            }

            public R next() {
                last = next;
                if (last!=null)
                    next = last.getPreviousBuild();
                else
                    throw new NoSuchElementException();
                return last;
            }

            public void remove() {
                if (last==null)
                    throw new UnsupportedOperationException();
                removeValue(last);
            }
        };
    }
1114833
public int getSize() {
        int count = 0;
        for (List<IIsotope> isotope : isotopes)
            if (isotope != null)
                count += isotope.size();
        return count;
    }
334539
@Override
	public Iterator<Entry<K, V>> iterator() {
		return new Iterator<Entry<K, V>>() {

			private final Entry<K, V>[] tab = KeyMap.this.table;

			private Entry<K, V> nextEntry;

			private int nextPos = 0;

			@Override
			public boolean hasNext() {
				if (nextEntry != null) {
					return true;
				}
				else {
					while (nextPos < tab.length) {
						Entry<K, V> e = tab[nextPos++];
						if (e != null) {
							nextEntry = e;
							return true;
						}
					}
					return false;
				}
			}

			@Override
			public Entry<K, V> next() {
				if (nextEntry != null || hasNext()) {
					Entry<K, V> e = nextEntry;
					nextEntry = nextEntry.next;
					return e;
				}
				else {
					throw new NoSuchElementException();
				}
			}

			@Override
			public void remove() {
				throw new UnsupportedOperationException();
			}
		};
	}
434058
public Iterator<AbstractJobInputVertex> getInputVertices() {

		final Collection<AbstractJobInputVertex> coll = this.inputVertices.values();

		return coll.iterator();
	}
856229
public Iterator iterator()
        {
        Query readAll = m_em.createQuery(
                createReadAllQuery(m_entityClass.getSimpleName()));
        return new JpaIterator(readAll, m_batchSize);
        }
18576
public List<TableGenerator<EntityMappings<T>>> getAllTableGenerator()
   {
      List<TableGenerator<EntityMappings<T>>> list = new ArrayList<TableGenerator<EntityMappings<T>>>();
      List<Node> nodeList = childNode.get("table-generator");
      for(Node node: nodeList)
      {
         TableGenerator<EntityMappings<T>>  type = new TableGeneratorImpl<EntityMappings<T>>(this, "table-generator", childNode, node);
         list.add(type);
      }
      return list;
   }
1049038
@NonNull
  @Override
  public Iterator<Node> iterator() {
    int i = nextIndex.get();
    if (i >= nodes.length) {
      return Collections.<Node>emptyList().iterator();
    } else {
      return Iterators.forArray(Arrays.copyOfRange(nodes, i, nodes.length, Node[].class));
    }
  }
577346
@Nonnull
    public Iterator<Long> iterator() {
        return new Iterator<Long>() {
            private long base2 = base;
            private int remaining = batchSize;

            @Override
            public boolean hasNext() {
                return remaining > 0;
            }

            @Override
            public Long next() {
                if (remaining == 0) {
                    throw new NoSuchElementException();
                }
                remaining--;
                try {
                    return base2;
                } finally {
                    base2 += increment;
                }
            }

            @Override
            public void remove() {
                throw new UnsupportedOperationException();
            }
        };
    }