Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /* Soot - a J*va Optimization Framework
   * Copyright (C) 1997-1999 Raja Vallee-Rai
   *
   * This library is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
   * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the
  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  * Boston, MA 02111-1307, USA.
  */
 
 /*
  * Modified by the Sable Research Group and others 1997-1999.  
  * See the 'credits' file distributed with Soot for the complete list of
  * contributors.  (Soot is distributed at http://www.sable.mcgill.ca/soot)
  */
 
 
 package soot.toolkits.scalar;
 
 import java.util.*;







Reference implementation for a FlowSet. Items are stored in an Array.
 
 public class ArraySparseSet extends AbstractFlowSet
 {
 	protected static final int DEFAULT_SIZE = 8; 
     
     protected int numElements;
     protected int maxElements;
     protected Object[] elements;
 
     public ArraySparseSet()
     {
          = ;
          = new Object[];
          = 0;
     }
     
     private ArraySparseSet(ArraySparseSet other)
     {
          = other.numElements;
          = other.maxElements;
          = other.elements.clone();
     }
    
    
Returns true if flowSet is the same type of flow set as this.
 
     private boolean sameType(Object flowSet)
     {
         return (flowSet instanceof ArraySparseSet);
     }
 
     public ArraySparseSet clone()
     {
         return new ArraySparseSet(this);
     }
 
     public Object emptySet()
     {
         return new ArraySparseSet();
     }
 
     public void clear()
     {
          = 0;
     }
     
     public int size()
     {
         return ;
     }
 
     public boolean isEmpty()
     {
         return  == 0;
     }

    
Returns a unbacked list of elements in this set.
 
     public List toList()
     {
         Object[] copiedElements = new Object[];
         System.arraycopy(, 0, copiedElements, 0, );
         return Arrays.asList(copiedElements);
     }
  /* Expand array only when necessary, pointed out by Florian Loitsch
   * March 08, 2002
   */
    public void add(Object e)
    {
      /* Expand only if necessary! and removes one if too:) */
        // Add element
            if(!contains(e)) {
              // Expand array if necessary
              if( == )
                doubleCapacity();
              [++] = e;
            }
    }
    private void doubleCapacity()
    {        
        int newSize =  * 2;
                    
        Object[] newElements = new Object[newSize];
                
        System.arraycopy(, 0, newElements, 0, );
         = newElements;
         = newSize;
    }    
    public void remove(Object obj)
    {
        int i = 0;
        while (i < this.) {
            if ([i].equals(obj))
            {
            	--;
            	//copy last element to deleted position
                [i] = [];
                //delete reference in last cell so that
                //we only retain a single reference to the
                //"old last" element, for memory safety
                [] = null;
                return;
            } else
                i++;
        }
    }
  public void union(FlowSet otherFlowFlowSet destFlow)
    {
      if (sameType(otherFlow) &&
          sameType(destFlow)) {
        ArraySparseSet other = (ArraySparseSetotherFlow;
        ArraySparseSet dest = (ArraySparseSetdestFlow;
        // For the special case that dest == other
            if(dest == other)
            {
                for(int i = 0; i < this.i++)
                    dest.add(this.[i]);
            }
        
        // Else, force that dest starts with contents of this
        else {
            if(this != dest)
                copy(dest);
            for(int i = 0; i < other.numElementsi++)
                dest.add(other.elements[i]);
        }
      } else
        super.union(otherFlowdestFlow);
    }
    public void intersection(FlowSet otherFlowFlowSet destFlow)
    {
      if (sameType(otherFlow) &&
          sameType(destFlow)) {
        ArraySparseSet other = (ArraySparseSetotherFlow;
        ArraySparseSet dest = (ArraySparseSetdestFlow;
        ArraySparseSet workingSet;
        
        if(dest == other || dest == this)
            workingSet = new ArraySparseSet();
        else { 
            workingSet = dest;
            workingSet.clear();
        }
        
        for(int i = 0; i < this.i++)
        {
            if(other.contains(this.[i]))
                workingSet.add(this.[i]);
        }
        
        if(workingSet != dest)
            workingSet.copy(dest);
      } else
        super.intersection(otherFlowdestFlow);
    }
    public void difference(FlowSet otherFlowFlowSet destFlow)
    {
      if (sameType(otherFlow) &&
          sameType(destFlow)) {
        ArraySparseSet other = (ArraySparseSetotherFlow;
        ArraySparseSet dest = (ArraySparseSetdestFlow;
        ArraySparseSet workingSet;
        
        if(dest == other || dest == this)
            workingSet = new ArraySparseSet();
        else { 
            workingSet = dest;
            workingSet.clear();
        }
        
        for(int i = 0; i < this.i++)
        {
            if(!other.contains(this.[i]))
                workingSet.add(this.[i]);
        }
        
        if(workingSet != dest)
            workingSet.copy(dest);
      } else
        super.difference(otherFlowdestFlow);
    }
    
    

Deprecated:
This method uses linear-time lookup. For better performance, consider using a java.util.HashSet instead, if you require this operation.
    public boolean contains(Object obj)
    {
        for(int i = 0; i < i++)
            if([i].equals(obj))
                return true;
                
        return false;
    }
    public boolean equals(Object otherFlow)
    {
      if (sameType(otherFlow)) {
        ArraySparseSet other = (ArraySparseSetotherFlow;
         
        if(other.numElements != this.)
            return false;
     
        int size = this.;
             
        // Make sure that thisFlow is contained in otherFlow  
            for(int i = 0; i < sizei++)
                if(!other.contains(this.[i]))
                    return false;
            /* both arrays have the same size, no element appears twice in one
             * array, all elements of ThisFlow are in otherFlow -> they are
             * equal!  we don't need to test again!
        // Make sure that otherFlow is contained in ThisFlow        
            for(int i = 0; i < size; i++)
                if(!this.contains(other.elements[i]))
                    return false;
             */
        
        return true;
      } else
        return super.equals(otherFlow);
    }
    public void copy(FlowSet destFlow)
    {
      if (sameType(destFlow)) {
        ArraySparseSet dest = (ArraySparseSetdestFlow;
        while(dest.maxElements < this.)
            dest.doubleCapacity();
    
        dest.numElements = this.;
        
        System.arraycopy(this., 0,
            dest.elements, 0, this.);
      } else
        super.copy(destFlow);
    }
New to GrepCode? Check out our FAQ X