Adds min() method to Iterator objects. The iterator will become
exhausted of elements after determining the minimum value.

@param self an Iterator
@return the minimum value
@see #min(java.util.Collection)
@since 1.5.5
482103
public static <T> T min(Iterator<T> self) {
        return min((Iterable<T>)toList(self));
    }
68344
public static Constraint min(final Number min) {
		return new Constraint("min", minPayload(min)) {
			public boolean isValid(Object actualValue) {
				return actualValue == null || (actualValue instanceof Number && min != null &&
						min.longValue() <= ((Number) actualValue).longValue());
			}
		};
	}
606618
public int getMin() {
        List<Integer> value = new ArrayList<Integer>();
        for (AnalysisType at : analysisType) {
            value.add(at.getValue());
        }
        return Collections.min(value);
    }
1103164
public static <T> Iterator<T> tail(Iterator<T> self) {
        if (!self.hasNext()) {
            throw new NoSuchElementException("Cannot access tail() for an empty Iterator");
        }
        self.next();
        return self;
    }
595024
public int getInt(final int min, final int max) {
		return min(min, max) + getInt(abs(max - min));
	}
415564
public static <T> T eachWithIndex(T self, Closure closure) {
        final Object[] args = new Object[2];
        int counter = 0;
        for (Iterator iter = InvokerHelper.asIterator(self); iter.hasNext();) {
            args[0] = iter.next();
            args[1] = counter++;
            closure.call(args);
        }
        return self;
    }
961886
@Override
    public <N extends Number> Expression<N> min(Expression<N> arg0)
    {
        // TODO Auto-generated method stub
        return null;
    }
943041
public void setMin(Double min) {
        String minStr = doubleToNiceStr(min);
        JQMCommon.setAttribute(input, "min", minStr);
        refreshMin(input.getElement().getId(), minStr);
        validateValue();
    }
14078
public static Iterator<String> iterator(Reader self) {
        final BufferedReader bufferedReader;
        if (self instanceof BufferedReader)
            bufferedReader = (BufferedReader) self;
        else
            bufferedReader = new BufferedReader(self);
        return new Iterator<String>() {
            String nextVal /* = null */;
            boolean nextMustRead = true;
            boolean hasNext = true;

            public boolean hasNext() {
                if (nextMustRead && hasNext) {
                    try {
                        nextVal = readNext();
                        nextMustRead = false;
                    } catch (IOException e) {
                        hasNext = false;
                    }
                }
                return hasNext;
            }

            public String next() {
                String retval = null;
                if (nextMustRead) {
                    try {
                        retval = readNext();
                    } catch (IOException e) {
                        hasNext = false;
                    }
                } else
                    retval = nextVal;
                nextMustRead = true;
                return retval;
            }

            private String readNext() throws IOException {
                String nv = bufferedReader.readLine();
                if (nv == null)
                    hasNext = false;
                return nv;
            }

            public void remove() {
                throw new UnsupportedOperationException("Cannot remove() from a Reader Iterator");
            }
        };
    }
1325503
static MinMax minmax(int[] input, final int start, final int length) {
        int max = input[start];
        int min = max;
        for (int i = length - 2, index = start + 1; i >= 0; i--, index++) {
            final int v = input[index];
            if (v > max) {
                max = v;
            }
            if (v < min) {
                min = v;
            }
        }

        return new MinMax(min, max);
    }
624322
public static <T> Iterator<T> toUnique(Iterator<T> self) {
        return new UniqueIterator<T>(self, null);
    }
724004
public BoundedAssertion getMin()
    {
    ICondition min = null;
    Iterator<ICondition> conditions = getConditions();
    for( int i = 0; i < 1; i++) min = conditions.next();
    return (BoundedAssertion) min;
    }
1011771
public static Iterator iterator(final ListModel self) {
        return new Iterator() {
            private int index = 0;

            public boolean hasNext() {
                return index < self.getSize();
            }

            public Object next() {
                return self.getElementAt(index++);
            }

            public void remove() {
                throw new UnsupportedOperationException("LisModel is immutable.");
            }
        };
    }
1165578
public void setMin(java.lang.Object _min) {
		getStateHelper().put(PropertyKeys.min, _min);
	}
325825
public final void setMinValue(final int minValue) {
        Condition.INSTANCE.ensureSmaller(minValue, getMaxValue(),
                "The minimum value must be less than the maximum value");
        this.minValue = minValue;
        setValue(Math.max(getValue(), minValue));
    }
329736
public static int size(Iterator self) {
        int count = 0;
        while (self.hasNext()) {
            self.next();
            count++;
        }
        return count;
    }
21615
public static Iterator<TableColumn> iterator(final TableColumnModel self) {
        return new Iterator<TableColumn>() {
            private int index = 0;

            public boolean hasNext() {
                return index > -1 && index < self.getColumnCount();
            }

            public TableColumn next() {
                return self.getColumn(index++);
            }

            public void remove() {
                if (hasNext()) self.removeColumn(self.getColumn(index--));
            }
        };
    }