//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
// PLEASE DO NOT EDIT WITHOUT THE EXPLICIT CONSENT OF THE AUTHOR! \\
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\

package ilog.language.design.backend;

import java.util.Iterator;


import ilog.language.util.IntIterator;
import ilog.language.util.DoubleIterator;
import ilog.language.util.ToIntMap;
import ilog.language.util.IntToIntMap;

public class IntSet extends RuntimeSet
{
  

  private IntToIntMap _map = new IntToIntMap();

  

  private int[] _array;

  

  private IntRange _intRange;

  

  private int _min = Integer.MAX_VALUE;

  

  private int _max = Integer.MIN_VALUE;

  

  public IntSet ()
    {
    }

  

  private IntSet (IntToIntMap map)
    {
      _map.include(map);
    }

  

  final ToIntMap map ()
    {
      return _map;
    }

  

  public final int[] array ()
    {
      if (_map.size() > 0 && (_array == null || _hasHoles))
        {
          _array = new int[_map.size()];

          if (_hasHoles)
            {
              ToIntMap.Entry[] entries = _resetIndices();
              for (int i = _array.length; i-->0;)
                {
                  IntToIntMap.Entry entry = (IntToIntMap.Entry)entries[i];
                  _array[entry.value()] = entry.key();
                }
            }
          else
            for (Iterator i = _map.iterator(); i.hasNext();)
              {
                IntToIntMap.Entry entry = (IntToIntMap.Entry)i.next();
                _array[entry.value()] = entry.key();
              }
        }

      return _array;
    }

  

  public final int firstInt () throws NoSuchElementException
    {
      if (size() == 0)
        throw new NoSuchElementException("first element of an empty set");

      return array()[0];
    }
    
  

  public final double firstReal () throws NoSuchElementException
    {
      return (double)firstInt();
    }
    
  

  public final Object firstObject () throws NoSuchElementException
    {
      return new RuntimeInt(firstInt());
    }
    

  

  public final int lastInt () throws NoSuchElementException
    {
      if (size() == 0)
        throw new NoSuchElementException("last element of an empty set");

      return array()[size()-1];
    }
    
  

  public final double lastReal () throws NoSuchElementException
    {
      return (double)lastInt();
    }
    
  

  public final Object lastObject () throws NoSuchElementException
    {
      return new RuntimeInt(lastInt());
    }
    

  

  public final int ord (int element) throws NoSuchElementException
    {
      if (_hasHoles) _resetIndices();

      int index = getIndex(element);
      if (index == -1)
        throw new NoSuchElementException(element+" doesn't belong to this set");

      return index;       
    }
    
  

  public final int ord (double element) throws NoSuchElementException
    {
      return ord((int)element);
    }
    
  

  public final int ord (Object element) throws NoSuchElementException
    {
      return ord(((RuntimeInt)element).value());
    }
    

  

  public final int next (int element) throws NoSuchElementException
    {
      int index = ord(element)+1;

      if (index == size())
        throw new NoSuchElementException(element+" has no successor in this set");

      return array()[index];        
    }
    
  

  public final double next (double element) throws NoSuchElementException
    {
      return (double)next((int)element);
    }
    
  

  public final Object next (Object element) throws NoSuchElementException
    {
      return new RuntimeInt(next(((RuntimeInt)element).value()));
    }
    

  

  public final int prev (int element) throws NoSuchElementException
    {
      int index = ord(element)-1;

      if (index == -1)
        throw new NoSuchElementException(element+" has no predecessor in this set");

      return array()[index];        
    }
    
  

  public final double prev (double element) throws NoSuchElementException
    {
      return (double)prev((int)element);
    }
    
  

  public final Object prev (Object element) throws NoSuchElementException
    {
      return new RuntimeInt(prev(((RuntimeInt)element).value()));
    }
    

  

  public final int nextc (int element) throws NoSuchElementException
    {
      return array()[(ord(element)+1) % size()];
    }
    
  

  public final double nextc (double element) throws NoSuchElementException
    {
      return (double)nextc((int)element);
    }
    
  

  public final Object nextc (Object element) throws NoSuchElementException
    {
      return new RuntimeInt(next(((RuntimeInt)element).value()));
    }
    

  

  public final int prevc (int element) throws NoSuchElementException
    {
      return array()[(ord(element)+size()-1) % size()];
    }
    
  

  public final double prevc (double element) throws NoSuchElementException
    {
      return (double)prevc((int)element);
    }
    
  

  public final Object prevc (Object element) throws NoSuchElementException
    {
      return new RuntimeInt(prevc(((RuntimeInt)element).value()));
    }
    
  

  public final RuntimeSet copy ()
    {
      return new IntSet(_map)._setHasHoles(_hasHoles)._setMaxIndex(_maxIndex);
    }      

  

  public final int getIndex (int element)
    {
      int index = _map.get(element);
      return index == _map.NOT_FOUND_VALUE && !_map.containsKey(element)
           ? -1
           : index;
    }

  

  public final int getIndex (double element)
    {
      return getIndex((int)element);
    }

  

  public final int getIndex (Object element)
    {
      return getIndex(((RuntimeInt)element).value());
    }

  

  public final int min ()
    {
      if (isEmpty())
        throw new NoSuchElementException("attempt to take the minimum element of an empty set");

      return _min;
    }

  

  public final int max ()
    {
      if (isEmpty())
        throw new NoSuchElementException("attempt to take the maximum element of an empty set");

      return _max;
    }

  

  public final void addInt (int element) 
    {
      add(element);
    }

  

  protected final RuntimeSet _add (int element)
    {
      if (!_map.containsKey(element))
        {
          _map.put(element,_maxIndex++);
          int min = size() == 1 ? element : Math.min(_min,element);
          int max = size() == 1 ? element : Math.max(_max,element);
          if (min != _min || max != _max) _intRange = null;
          _array = null;
          _min = min;
          _max = max;
        }

      return this;
    }

  

  protected final RuntimeSet _add (double element)
    {
      return _add((int)element);
    }

  

  protected final RuntimeSet _add (Object element)
    {
      return _add(((RuntimeInt)element).value());
    }

  

  protected final RuntimeSet _remove (int element)
    {
      if (_hasHoles |= (_map.remove(element) >= 0))
        {
          if (element == _min) _recomputeMin();
          if (element == _max) _recomputeMax();
          _array = null;
        }

      return this;
    }

  

  protected final RuntimeSet _remove (double element)
    {
      return _remove((int)element);
    }

  

  protected final RuntimeSet _remove (Object element)
    {
      return _remove(((RuntimeInt)element).value());
    }

  

  public final boolean contains (int element)
    {
      return _map.containsKey(element);
    }

  

  public final boolean contains (double element)
    {
      return _map.containsKey((int)element);
    }

  

  public final boolean contains (Object element)
    {
      return _map.containsKey(((RuntimeInt)element).value());
    }

  

  public final boolean contains (RuntimeSet set)
    {
      for (IntIterator i = set.intIterator(false); i.hasNext();)
        if (!contains(i.next())) return false;

      return true;
    }

  

  protected final RuntimeSet _union (RuntimeSet set)
    {
      for (IntIterator i = set.intIterator(true); i.hasNext();)
        _add(i.next());

      return this;
    }

  

  public final RuntimeSet _intersection (RuntimeSet set)
    {
      for (IntIterator i = intIterator(false); i.hasNext();)
        {
          int element = i.next();
          if (!set.contains(element))
            _remove(element);
        }

      return this;
    }

  

  public final RuntimeSet _minus (RuntimeSet set) 
    {
      for (IntIterator i = set.intIterator(false); i.hasNext();)
        _remove(i.next());

      return this;
    }

  

  public final RuntimeSet _exclusion (RuntimeSet set)
    {
      for (IntIterator i = set.intIterator(true); i.hasNext();)
        {
          int element = i.next();
          if (contains(element))
            _remove(element);
          else
            _add(element);             
        }

      return this;
    }

  

  public final void _recomputeMin ()
    {
      _min = Integer.MAX_VALUE;
      for (IntIterator i = intIterator(false); i.hasNext();)
        _min = Math.min(_min,i.next());
      _intRange = null;
    }

  

  public final void _recomputeMax ()
    {
      _max = Integer.MIN_VALUE;
      for (IntIterator i = intIterator(false); i.hasNext();)
        _max = Math.max(_max,i.next());
      _intRange = null;
    }

  

  public final IntRange toIntRange ()
    {
      if (_intRange != null) return _intRange;
      return _intRange = isEmpty() ? new IntRange() : new IntRange(_min,_max);
    }

  

  public final IntIterator intIterator ()
    {
      return intIterator(_isLocked);
    }

  

  public final IntIterator intIterator (boolean ordered)
    {
      return ordered ? (IntIterator)orderedIterator() : _map.keys();
    }

  

  public final DoubleIterator realIterator (boolean ordered)
    {
      return new RealIterator(intIterator(ordered));
    }

  

  public final DoubleIterator realIterator ()
    {
      return new RealIterator((IntIterator)intIterator());
    }

  

  public final Iterator iterator (boolean ordered)
    {
      return new BoxedIntIterator(intIterator(ordered));
    }

  

  public final Iterator iterator ()
    {
      return new BoxedIntIterator((IntIterator)intIterator());
    }

  

  public final IntIterator orderedIterator ()
    {
      return new OrderedIterator(array());
    }

  

  public final IntIterator backwardIntIterator ()
    {
      return new BackwardIterator(array());
    }

  

  public final DoubleIterator backwardRealIterator ()
    {
      return new RealIterator(backwardIntIterator());
    }

  

  public final Iterator backwardIterator ()
    {
      return new BoxedIntIterator(backwardIntIterator());
    }

  

  public final IntIterator indexIterator ()
    {
      return _map.values();
    }

  

  public final boolean equals (Object object)
    {
      if (this == object)
        return true;

      if (!(object instanceof IndexableContainer)) // it may be an IntRange
        return false;

      IndexableContainer other = (IndexableContainer)object;

      if (size() != other.size())
        return false;

      for (IntIterator i = intIterator(false); i.hasNext();)
        if (!other.contains(i.next())) return false;

      return true;
    }

  

  public final boolean equals (Object object, int[] permutation)
    {
      if (this == object)
        {
          for (int i=0; i<permutation.length; i++) permutation[i] = i;
          return true;
        }

      if (!(object instanceof Indexable)) // it may be an IntRange
        return false;

      Indexable other = (Indexable)object;

      if (size() != other.size())
        return false;

     for (Iterator i = _map.iterator(); i.hasNext();)
       {
         IntToIntMap.Entry entry = (IntToIntMap.Entry)i.next();
         int index = other.getIndex(entry.key());
         if (index == -1) return false;
         permutation[index] = entry.value();
       }

      return true;
    }

  public final String toString ()
    {
      StringBuffer buf = new StringBuffer("{");

      int l = size();
      
      for (IntIterator i = intIterator(true); i.hasNext();)
        buf.append(i.next()).append(--l == 0 ? "" : ", ");

      return buf.append("}").toString();
    }

  private static class BoxedIntIterator implements Iterator
    {
      private IntIterator _iterator;

      BoxedIntIterator (IntIterator iterator)
        {
          _iterator = iterator;
        }

      public final boolean hasNext ()
        {
          return _iterator.hasNext();
        }

      public final Object next ()
        {
          return new RuntimeInt(_iterator.next());
        }

      public final void remove ()
        {
          throw new UnsupportedOperationException();
        }
    }

  private static class RealIterator implements DoubleIterator
    {
      private IntIterator _iterator;

      RealIterator (IntIterator iterator)
        {
          _iterator = iterator;
        }

      public final boolean hasNext ()
        {
          return _iterator.hasNext();
        }

      public final double next ()
        {
          return (double)_iterator.next();
        }
    }

  private static class OrderedIterator implements IntIterator
    {
      private int[] _array;
      private int _index = 0;

      OrderedIterator (int[] array)
        {
          _array = array;
        }

      public final boolean hasNext ()
        {
          return _array == null ? false : _index < _array.length;
        }

      public final int next ()
        {
          return _array[_index++];
        }
    }

  private static class BackwardIterator implements IntIterator
    {
      private int[] _array;
      private int _index;

      BackwardIterator (int[] array)
        {
          _array = array;
          _index = _array.length;
        }

      public final boolean hasNext ()
        {
          return _array == null ? false : _index > 0;
        }

      public final int next ()
        {
          return _array[--_index];
        }
    }
}

This file was generated on Tue Aug 03 09:28:17 PDT 2004 from file IntSet.java
by the ilog.language.tools.Hilite Java tool written by Hassan Aït-Kaci