IntervalDomainIterator.java

  1. /* Copyright 2015 Laurent COCAULT
  2.  * Licensed to Laurent COCAULT under one or more contributor license agreements.
  3.  * See the NOTICE file distributed with this work for additional information
  4.  * regarding copyright ownership. Laurent COCAULT licenses this file to You
  5.  * under the Apache License, Version 2.0 (the "License"); you may not use this
  6.  * file except in compliance with the License.  You may obtain a copy of the
  7.  * License at
  8.  *
  9.  *   http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  17. package org.csp.constraint.model;

  19. import java.util.Iterator;
  20. import java.util.NoSuchElementException;

  22. /**
  23.  * Iterator on the values of an interval domain.
  24.  */
  25. class IntervalDomainIterator<T extends Value<T>> implements Iterator<T> {

  27.     /**
  28.      * Domain of values to iterate.
  29.      */
  30.     private IntervalDomain<T> domain_;

  32.     /**
  33.      * Current value.
  34.      */
  35.     private T value_;

  37.     /**
  38.      * Next value.
  39.      */
  40.     private T next_;

  42.     /**
  43.      * Constructor of the iterator.
  44.      * @param domain
  45.      *            Domain of values to iterate
  46.      */
  47.     public IntervalDomainIterator(final IntervalDomain<T> domain) {
  48.         domain_ = domain;
  49.         value_ = null;
  50.         next_ = domain.getFirstValue();
  51.     }

  53.     /**
  54.      * {@inheritDoc}
  55.      */
  56.     @Override
  57.     public boolean hasNext() {
  58.         return next_ != null;
  59.     }

  61.     /**
  62.      * {@inheritDoc}
  63.      */
  64.     @Override
  65.     public T next() {

  67.         // Value is the next value
  68.         if (next_ == null) {
  69.             throw new NoSuchElementException();
  70.         }
  71.         value_ = next_;

  73.         // Compute the next one
  74.         boolean finished = false;
  75.         final Iterator<Interval<T>> index = domain_.getValues().iterator();
  76.         while (index.hasNext() && !finished) {
  77.             final Interval<T> interval = index.next();
  78.             if (interval.isInInterval(value_)) {
  79.                 // Current value found : global iteration is over
  80.                 finished = true;

  82.                 if (interval.isInInterval(value_.nextValue())) {
  83.                     // The next value is in the interval
  84.                     next_ = value_.nextValue();
  85.                 } else if (index.hasNext()) {
  86.                     // Get the next internal minimum
  87.                     next_ = index.next().getMinValue();
  88.                 } else {
  89.                     // No next value
  90.                     next_ = null;
  91.                 }
  92.             }
  93.         }

  95.         return value_;
  96.     }

  98.     /**
  99.      * {@inheritDoc}
  100.      */
  101.     @Override
  102.     public void remove() {
  103.         if (value_ == null) {
  104.             // Next has not been called yet
  105.             throw new IllegalStateException();
  106.         } else {
  107.             // Remove the value
  108.             domain_.removeValue(value_);
  109.         }
  110.     }

  112. }
Created with JaCoCo 0.7.4.201502262128