IRHandleDataFlowSet.hpp

Go to the documentation of this file.

#ifndef IRHandleDataFlowSet_h
#define IRHandleDataFlowSet_h

#include <iostream>
#include <set>
#include <algorithm>
#include <iterator>
#include <OpenAnalysis/DataFlow/DataFlowSet.hpp>

// abstract interface that this class implements
//#include <OpenAnalysis/DataFlow/DataFlowSet.hpp>

namespace OA {
  namespace DataFlow {

template <class T> class IRHandleIterator;

template <class T> 
class IRHandleDataFlowSet : public virtual DataFlowSet {
public:
  IRHandleDataFlowSet() {}
  IRHandleDataFlowSet(const IRHandleDataFlowSet<T> &other) : mSet(other.mSet) {}
  ~IRHandleDataFlowSet() {}

  OA_ptr<DataFlowSet> clone()
    { OA_ptr<IRHandleDataFlowSet<T> > retval;
      retval = new IRHandleDataFlowSet<T>(*this); return retval; }
  
  // param for these can't be const because will have to 
  // dynamic cast to specific subclass
  //IRHandleDataFlowSet<T>& operator =(IRHandleDataFlowSet<T> &other)
  //{ 
  //  mSet = other.mSet;
  //  return *this;
 // }


  bool operator ==(DataFlowSet &other) const
  { 
    IRHandleDataFlowSet<T>& recastOther 
        = dynamic_cast<IRHandleDataFlowSet<T>&>(other);
    return mSet == recastOther.mSet; 
  }

  bool operator !=(DataFlowSet &other) const
  { 
    IRHandleDataFlowSet<T>& recastOther 
        = dynamic_cast<IRHandleDataFlowSet<T>&>(other);
    return mSet != recastOther.mSet; 
  }

  IRHandleDataFlowSet<T>& setUnion(DataFlowSet &other)
  { 
    IRHandleDataFlowSet<T>& recastOther 
        = dynamic_cast<IRHandleDataFlowSet<T>&>(other);
    std::set<T> temp;
    std::set_union(mSet.begin(), mSet.end(), 
                   recastOther.mSet.begin(), recastOther.mSet.end(),
                   std::inserter(temp,temp.end()));
    mSet = temp;
    return *this;
  }

 /* IRHandleDataFlowSet<T>& setIntersect(IRHandleDataFlowSet<T> &other)
  { 
    std::set<T> temp;
    std::set_intersection(mSet.begin(), mSet.end(), 
                          other.mSet.begin(), other.mSet.end(),
                          std::inserter(temp,temp.end()));
    mSet = temp;
    return *this;
  }*/


  IRHandleDataFlowSet<T>& setIntersect(DataFlowSet &other)
  {
    IRHandleDataFlowSet<T>& recastOther
        = dynamic_cast<IRHandleDataFlowSet<T>&>(other);
    std::set<T> temp;
    std::set_intersection(mSet.begin(), mSet.end(),
                   recastOther.mSet.begin(), recastOther.mSet.end(),
                   std::inserter(temp,temp.end()));
    mSet = temp;
    return *this;
  }


  void dump(std::ostream &os)
  {
      os << "IRHandleDataFlowSet: mSet = ";
      // iterate over IRHandle's and print out hvals
      typename std::set<T>::iterator iter;
      for (iter=mSet.begin(); iter!=mSet.end(); iter++) {
          os << (*iter).hval() << ", ";
      }
      os << std::endl;
  }

  void dump(std::ostream &os, OA_ptr<IRHandlesIRInterface> ir)
  {
      os << "IRHandleDataFlowSet: mSet = ";
      // iterate over IRHandle's and have the IR print them out
      typename std::set<T>::iterator iter;
      for (iter=mSet.begin(); iter!=mSet.end(); iter++) {
          os << ir->toString(*iter) << ", ";
      }
      os << std::endl;
  }

  // methods specific to IRHandleDataFlowSet
  void insert(T h) { mSet.insert(h); }
  void remove(T h) { mSet.erase(h); }

  bool handleInSet(T h) { return (mSet.find(h)!=mSet.end()); }

  bool empty() { return mSet.empty(); }

protected:
  std::set<T> mSet;

  friend class IRHandleIterator<T>;

};

//--------------------------------------------------------------------
//--------------------------------------------------------------------
//template <class T> class std::set<T>::iterator;

template <class T>
class IRHandleIterator {
public:
    // have to get OA_ptr to a set because otherwise the set
    // might disappear before user of this iterator references it
    IRHandleIterator (OA_ptr<IRHandleDataFlowSet<T> > DFSet) : mDFSet(DFSet) 
    { hIter = mDFSet->mSet.begin(); }
    ~IRHandleIterator () {}

    void operator ++ () { if (hIter != mDFSet->mSet.end()) hIter++; }
    void operator++(int) { ++*this; }  // postfix
    
    bool isValid() const { return (hIter != mDFSet->mSet.end()); }
    
    T current() const { return (*hIter); }

private:
    OA_ptr<IRHandleDataFlowSet<T> > mDFSet;
    typename std::set<T>::iterator hIter;
};
 

  } // end of DataFlow namespace
} // end of OA namespace

#endif