package nonNegIntSet2;

import java.util.ArrayList;

/**
 * @author rupchurch<br>
 * 
 * Created on Mar. 7, 2007<br>
 * Provides for creating and manipulating sets of non-negative integers (0...).
 *
 */

public class NonNegIntSet {
    
//Attributes
    private final int DEFAULT_SIZE=100;
    private ArrayList<Integer> contents = new ArrayList(DEFAULT_SIZE);

    
//Constructors

//
/**
 * Creates the empty set<br>
 * Postcondition: Creates an empty set, cardinality()==0 
 */
NonNegIntSet(){

}

/**
 * Creates a set from the values of the array that are greater than or equal to 0<br>
 * Postcondition: For all x in values, such that 0<=x, isElement(x).
 * @param values - ints which become part of the set
 */
NonNegIntSet(int[] values){
	
	for(int i: values)
    	this.insert(i);
}

//Set Methods

/**
 * 
 * Precondition: none<br>
 * Postcondition: true is the set is empty, false otherwise
 *@return true is the set is empty, false otherwise
 */
public boolean isEmpty(){
	return this.contents.size() == 0;
	} 

/**
 * 
 * Precondition: none<br>
 * Postcondition: return the number of elements in the set
 *@return the number of elements in the set
 */
public int cardinality(){
    return this.contents.size();}

/**
 * 
 * Precondition: none<br>
 * Postcondition: if 0<=element then return this.contents[element] else return false
 *@param element the int for inclusion in the set
 *@return true if element is in the set, false otherwise
 */
public boolean isElement(int element){
	return this.contents.contains(element);
    	
} 

/**
 * 
 * Precondition: none<br>
 * Postcondition:  if every element of s is an element of this return true else return false
 *@param s -  the set to test for containment
 *@return if s is a subset of this then return true else return false
 */
public boolean contains(NonNegIntSet s){
	
    if (this.contents.size() >= s.contents.size()){
    	for(int i: s.contents){
    		if(!this.contents.contains(i))
    			return false;
    	}
    	return true;
    }
    else return false;	
} 

/**
 * 
 * Precondition: none<br>
 * Postcondition: returns true if the two sets contain precisely the same elements, otherwise false
 *@param s -  the NonNegIntSet to compare to this
 *@return true is the sets have the same elements, false if they do not
 */
public boolean equals(NonNegIntSet s){
	
	boolean result=true;
    if(this.contents.size() != s.contents.size())
    	result=false;
    else {
    	for(int i: this.contents){
    		if(this.contents.contains(i) == s.contents.contains(i))
    			result = true;
    		else
    			return false;
    	}
    }
    
    return result;} 

/**
 * 
 * Precondition: none<br>
 * Postcondition: the specified elemetn is added to this Set if it is not already present.  
 * If this Set already contained ths epecified element, the set is left unchanged and flase has been returned.  
 * If the element has been inserted in the Set, true has been returned.
 *@param element - the int to be added to the set
 *@return true is the sets have the same elements, false if they do not
 */
public boolean  insert(int element){
	boolean result = false;
	
	if(element>= 0){
		this.contents.ensureCapacity(element);
		result =! isElement(element);
		if(!isElement(element)){
			this.contents.add(element);
			result = true;
			return result;
		}
	}
	
    return false;

	} 
//
/**
 * 
 * Precondition: none<br>
 * Postcondition: element has been removed from the Set, if it was present and true was returned, return false otherwise
 *@param element the int to be removed from the set
 *@return true if the element is removed from the set, false otherwise
 */
public boolean remove(int element){
	
		boolean result=false;
	    if(isElement(element)){
	    	this.contents.remove(new Integer(element));
	    	result=true;
	    }
	    return result;}

/**
 * 
 * Precondition: none<br>
 * Postcondition: this.equals(this.copy()) && this!=this.copy()
 *@return NonNegIntSet which has the same elements as this
 */
public NonNegIntSet copy(){
	
	NonNegIntSet a = new NonNegIntSet();
	
	for(int i: this.contents)
			a.insert(i);
	
		return a;}


//Operations

/**
 * 
 * Precondition: none<br>
 * Postcondition: for all x in the result, this.isElement(x) || s.isElement(x)
 *@param s - the set of elements to combine with the element of this
 *@return the set consisting of those elements in this or in s
 */
public NonNegIntSet union(NonNegIntSet s){
	
	for(int i: s.contents)
		if(!this.contents.contains(i)){
			this.insert(i);
		}
		return this;} 

/**
 * 
 * Precondition: none<br>
 * Postcondition: for all x in the result, this.isElement(x) && s.isElement(x)
 *@param s the set of elements to find in common with this
 *@return the set of all elements the two sets have in common
 */            
  public NonNegIntSet intersection(NonNegIntSet s){
	  
	  NonNegIntSet a = new NonNegIntSet();
      
	  for(int i: this.contents) {	
    	  if (this.isElement(i) && s.isElement(i)) 
    		  a.insert(i);}
      return a;
  } 


  /**
   * 
   * Precondition: none<br>
   * Postcondition: for all x in the result, this.isElement(x) && !s.isElement(x)
   *@param s - the set whose element are not to be in the result
   *@return the set of elements in this that are not in s
   */
  public NonNegIntSet difference(NonNegIntSet s){
	  
	  NonNegIntSet a = new NonNegIntSet();
	  
	  for(int i: this.contents) {	
    	  if (this.isElement(i) && !s.isElement(i)) 
    		  a.insert(i);
	  }
	  return a;
     } 


  //Utilities
 
  
  /**
   * The representation is {int, int, int} beginning with the smallest value 
   *  in the set to the largest from left to right.
   *@return a String representation of the  Set
   */
public String toString(){
	
	String result="{";
    int elementcount=0;
    for(int i: this.contents)
	if(isElement(i))
	    if(elementcount>0) 
	    	result+=", "+i;
	    else {
		elementcount++;
		result+=i;
	    }
    return result+"}";} 
   
   //Needed for junit testing. visibility must be public due to inheritance
   //DO NOT MODIFY
    public boolean equals(Object o){
        if (o.getClass() == this.getClass())
            return this.equals((NonNegIntSet)o);
        else
            return false;
    }

    

}