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

package hlt.language.util;

import java.util.BitSet;
import java.util.AbstractList;
import java.util.Vector;
import java.util.Enumeration;
import java.util.Iterator;

public class SetOf
{
  

  AbstractList base;
  
  

  BitSet carrier;

  

  public SetOf (Object[] base, boolean synchronize)
  {
    if (synchronize)
      this.base = new Vector(base.length);
    else
      this.base = new ArrayList(base.length);

    for (int i=0; i<base.length; i++)
      this.base.add(base[i]);
    carrier = new BitSet(base.length);
  }

  

  public SetOf (Object[] base)
  {
    this.base = new ArrayList(base.length);

    for (int i=0; i<base.length; i++)
      this.base.add(base[i]);
    carrier = new BitSet(base.length);
  }

  

  public SetOf (AbstractList base)
  {
    this.base = base;
    carrier = new BitSet(this.base.size());
  }

  

  public SetOf (AbstractList base, int index)
  {
    new SetOf(base).add(index);
  }

  

  public SetOf (Object[] base, int index)
  {
    new SetOf(base).add(index);
  }

  

  public SetOf (AbstractList base, Object object)
  {
    new SetOf(base).add(object);
  }

  

  public SetOf (Object[] base, Object object)
  {
    new SetOf(base).add(object);
  }

  

  public SetOf (SetOf set)
  {
    base = set.base;
    carrier = (BitSet)set.carrier.clone();
  }

  

  public SetOf (Object[] base, BitSet carrier)
  {
    this.base = new ArrayList(base.length);
    for (int i=0; i<base.length; i++)
      this.base.add(base[i]);
    this.carrier = carrier;
  }

  

  public SetOf (AbstractList base, BitSet carrier)
  {
    this.base = base;
    this.carrier = carrier;
  }

  //\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\

  

  
  int[] indices = null;

  

  private final int count ()
  {
    return carrier.size();
  }

  

  final void buildIndices ()
  {
    if (!isEmpty())
      {
	indices = new int[count()];
	int index = 0;
	for (int i = carrier.nextSetBit(0); i >= 0; i = carrier.nextSetBit(i+1))	  
	  indices[index++] = i;
      }
  }

  

  private static final BitSet EMPTY_BITSET = new BitSet();
  

  private static SetOf FULL_SET;

  //\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\

  

  public final int size ()
  {
    if (indices == null)
      return count();

    return indices.length;
  }

  

  public final SetOf top ()
  {
    if (FULL_SET==null || FULL_SET.base != base)
      {
	FULL_SET = new SetOf(base);
	for (int i=0; i<base.size(); i++)	  
	  FULL_SET.carrier.set(i);
      }
    return FULL_SET;
  }

  

  public final boolean isFull ()
  {
    return carrier.equals(top().carrier);
  }

  

  public final boolean isEmpty ()
  {
    return carrier.equals(EMPTY_BITSET);
  }

  

 
  public final int indexOf (Object object)
  {
    if (object instanceof Indexed)
      // WARNING: this works only if
      return ((Indexed)object).index; // index is the position in base 

    return base.indexOf(object);
  }

  

  public SetOf add (int index)
  {
    if (indices == null)
      {
	carrier.set(index);
	return this;
      }

    if (!carrier.get(index))
      {
	carrier.set(index);
	indices = null;
      }

    return this;
  }
  
  

  public SetOf add (Object object)
  {
    carrier.set(indexOf(object));     
    return this;
  }

  

  public final static SetOf add (SetOf s, int index)
  {
    SetOf newset = new SetOf(s);
    newset.carrier.set(index);
    return newset;
  }

  

  public SetOf remove (int index)
  {
    if (indices == null)
      {
	carrier.clear(index);
	return this;
      }

    if (carrier.get(index))
      {
	carrier.clear(index);
	indices = null;
      }

    return this;
  }

  

  public SetOf remove (Object object)
  {
    return remove(indexOf(object));
  }

  

  public final static SetOf remove (SetOf s, int index)
  {
    SetOf newset = new SetOf(s);
    newset.carrier.clear(index);
    return newset;
  }

  

  public final int firstIndex ()
  {
    if (!isEmpty())
      {
	if (indices != null)
	  return indices[0];

	for (int i=0; i<base.size(); i++)	  
	  if (carrier.get(i))
	    return i;
      }

    return -1;
  }

  

  public final Object firstElement ()
  {
    int i = firstIndex();
    return (i<0) ? null : base.get(i);
  }

  

  public final SetOf union (SetOf other)
  {
    if (indices == null)
      {
	carrier.or(other.carrier);
	return this;
      }

    if (!other.isSubsetOf(this))
      {
	carrier.or(other.carrier);
	indices = null;
      }

    return this;
  }

  

  public final static SetOf union (SetOf s1, SetOf s2)
  {
    SetOf newset = new SetOf(s1);
    newset.carrier.or(s2.carrier);
    return newset;
  }

  

  public final SetOf intersection (SetOf other)
  {
    if (indices == null)
      {
	carrier.and(other.carrier);
	return this;
      }

    if (!this.isSubsetOf(other))
      {
	carrier.and(other.carrier);
	indices = null;
      }

    return this;
  }

  

  public final static SetOf intersection (SetOf s1, SetOf s2)
  {
    SetOf newset = new SetOf(s1);
    newset.carrier.and(s2.carrier);
    return newset;
  }

  

  public final SetOf minus (SetOf other)
  {
    if (indices == null)
      {
	carrier.or(other.carrier);
	carrier.xor(other.carrier);
	return this;
      }

    if (!intersection(this,other).isEmpty())
      {
	carrier.or(other.carrier);
	carrier.xor(other.carrier);
	indices = null;
      }

    return this;
  }

  

  public final static SetOf minus (SetOf s1, SetOf s2)
  {
    SetOf newset = new SetOf(s1);
    newset.carrier.or(s2.carrier);
    newset.carrier.xor(s2.carrier);
    return newset;
  }

  

  public final SetOf not ()
  {
    carrier.xor(top().carrier);
    indices = null;
    return this;
  }

  

  public final static SetOf not (SetOf s)
  {
    SetOf newset = new SetOf(s);
    newset.carrier.xor(s.top().carrier);
    return newset;
  }

  

  public final boolean contains (int index)
  {
    return carrier.get(index);
  }

  

  public final boolean contains (Object object)
  {
    return carrier.get(indexOf(object));
  }

  

  public final boolean isSubsetOf (SetOf other)
  {
    BitSet intersection = (BitSet)carrier.clone();
    intersection.and(other.carrier);
    return carrier.equals(intersection);
  }

  

  public final boolean isStrictSubsetOf (SetOf other)
  {
    return isSubsetOf(other) && size() != other.size();
  }

  

  public final boolean isEqualTo (SetOf other)
  {
    return carrier.equals(other.carrier);
  }

  

  public boolean equals (Object other)
  {
    if (other instanceof SetOf)
      return this.isEqualTo(((SetOf)other));
    return false;
  }

  

  public int hashCode ()
  {
    return carrier.hashCode();
  }

  

  public String toString ()
  {
    String s = "";
    for (Iterator i=iterator(); i.hasNext();)      
      {
	if (s.length() > 0)
	  s += ", ";
	s += i.next().toString();
      }
    return "{" + s + "}";
  }

  

  public final String toBitString ()
  {
    return toBitString('0','1');
  }

  

  public final String toBitString (char out, char in)
  {
    StringBuilder s = new StringBuilder();
    for (int i=0; i<base.size(); i++)      
      s.append(carrier.get(i) ? in : out);
    return s.toString();
  }

  

  public final Enumeration elements ()
  {
    return new SetEnumeration(this);
  }

  

  public final Iterator iterator ()
  {
    return new SetIterator(this);
  }

  

  public final IndexEnumeration indices ()
  {
    return new SetIndices(this);
  }

}

This file was generated on Sat May 11 08:40:08 CEST 2019 from file SetOf.java
by the hlt.language.tools.Hilite Java tool written by Hassan Aït-Kaci