main page namespaces classes files
ELL home

src/ell/StatePairCollector.cc

Go to the documentation of this file.

#include "ell/StatePairCollector.hh"

#include <biu/assertbiu.hh>

//##############################################################################
//##############################################################################

namespace ell {
    
    SPC_Counting::SPC_Counting()
     :  lastAdded_s1(NULL)
        , lastAdded_s2(NULL)
        , statePairCount(0)
    {
    }
    
    SPC_Counting::~SPC_Counting()
    {
        clearLastAdded();
    }
    
      // This function is used to track all added intermediate States.
      // @param s the added State
    void 
    SPC_Counting::add(const StatePair& s) {
        assertbiu(s.first != NULL, "first of the collected State pair is NULL");
        assertbiu(s.second!=NULL, "second of the collected State pair is NULL");
        
          // store a state copy
        lastAdded_s1 = s.first->clone(lastAdded_s1);
        lastAdded_s2 = s.second->clone(lastAdded_s2);
          // increase counter
        statePairCount++;
    }
    
      // This function is used to track all added intermediate States.
      // @param s the added State
    void 
    SPC_Counting::add(const State* const s1_, const State*const s2_) {
        assertbiu(s1_ != NULL, "first of the collected State pair is NULL");
        assertbiu(s2_ != NULL, "second of the collected State pair is NULL");
        
          // store a state copy
        lastAdded_s1 = s1_->clone(lastAdded_s1);
        lastAdded_s2 = s2_->clone(lastAdded_s2);
          // increase counter
        statePairCount++;
    }
    
      // Returns number of added States.
      // @return the number of added states
    size_t 
    SPC_Counting::size() const {
        return statePairCount;
    }
     
      // Returns last added State.
      // @return the last added State
    const SPC_Counting::StatePair 
    SPC_Counting::getLastAdded() const {
        return StatePair(lastAdded_s1,lastAdded_s2);
    }

} // namespace ell

//##############################################################################
//##############################################################################


namespace ell {
    
    SPC_Listing::SPC_Listing()
      : statePairList() 
    {}
    
    SPC_Listing::~SPC_Listing()
    {
          // delete all collected State objects
        for (   List::iterator it = statePairList.begin();
                it != statePairList.end(); it++ ) 
        {
            delete it->first;
            delete it->second;          
        }
          // clear invalid pointer list
        statePairList.clear();
    }

      // This function is used to track all added intermediate State pairs.
      // @param s the added State
    void 
    SPC_Listing::add(const StatePair& s) {
        assertbiu(s.first != NULL, "first of the collected State pair is NULL");
        assertbiu(s.second!=NULL, "second of the collected State pair is NULL");
          // store a copy of s
        statePairList.push_back(StatePair(s.first->clone(),s.second->clone()));
    }
    
      // This function is used to track all added intermediate States.
      // @param s the added State
    void 
    SPC_Listing::add(const State* const s1_, const State*const s2_) {
        assertbiu(s1_ != NULL, "first of the collected State pair is NULL");
        assertbiu(s2_ != NULL, "second of the collected State pair is NULL");
          // store a state copy
        statePairList.push_back(StatePair(s1_->clone(),s2_->clone()));
    }

      // Returns number of added States.
      // @return the number of added states
    size_t 
    SPC_Listing::size() const {
        return statePairList.size();
    }
     
      // Returns last added State.
      // @return the last added State
    const SPC_Listing::StatePair
    SPC_Listing::getLastAdded() const {
        return *(statePairList.rbegin());
    }
    

      // Returns a list of all added States.
      // @return the State list
    const SPC_Listing::List&
    SPC_Listing::getList() const {
        return statePairList;
    }
    

} // namespace ell


//##############################################################################
//##############################################################################

namespace ell
{

    SPC_Outstream::SPC_Outstream(   std::ostream& out_ 
                                    , const std::string& separator
                                    , const std::string& toAppend)
     :  SPC_Counting()
        , out(out_)
        , strSep(separator)
        , strAppend(toAppend)
    {
    }
    
    SPC_Outstream::~SPC_Outstream()
    {
          // ensure that output is stored by the stream
        out.flush();
    }

      // This function is used to track all added intermediate States.
      // @param s the added State
    void 
    SPC_Outstream::add(const StatePair& s) {
        assertbiu(s.first != NULL, "first of the collected State pair is NULL");
        assertbiu(s.second!=NULL, "second of the collected State pair is NULL");
          // call handler of superclass
        SPC_Counting::add(s);
          // print to stream
        printToStream();
    }

    void 
    SPC_Outstream::add(const State* const s1_, const State*const s2_) {
        assertbiu(s1_ != NULL, "first of the collected State pair is NULL");
        assertbiu(s2_ != NULL, "second of the collected State pair is NULL");
          // call handler of superclass
        SPC_Counting::add(s1_, s2_);
          // print to stream
        printToStream();
    }

} // namespace ell


//##############################################################################
//##############################################################################

namespace ell {

    SPC_MinPair::SPC_MinPair( const bool pairsAddedInAscOrder_ )
     :  SPC_Counting()
        , pairsAddedInAscOrder(pairsAddedInAscOrder_)
        , minPair_s1(NULL)
        , minPair_s2(NULL)
        , minPair_max(NULL)
    {
    }
    
    SPC_MinPair::~SPC_MinPair()
    {
          // clear local data structures
        clearMinPair();
    }

      // This function is used to track all added intermediate States.
      // @param s the added State
    void 
    SPC_MinPair::add(const StatePair& s) {
        assertbiu(s.first != NULL, "first of the collected State pair is NULL");
        assertbiu(s.second!=NULL, "second of the collected State pair is NULL");
          // call handler of superclass
        SPC_Counting::add(s);
          // check if last added pair is smaller
        checkMinPair();
    }

    void 
    SPC_MinPair::add(const State* const s1_, const State*const s2_) {
        assertbiu(s1_ != NULL, "first of the collected State pair is NULL");
        assertbiu(s2_ != NULL, "second of the collected State pair is NULL");
          // call handler of superclass
        SPC_Counting::add(s1_, s2_);
          // check if last added pair is smaller
        checkMinPair();
    }

      // Returns last minimal added State pair.
      // @return the minimal added State pair
    const SPC_Counting::StatePair 
    SPC_MinPair::getMinPair() const {
        return StatePair(minPair_s1,minPair_s2);
    }
    
    void
    SPC_MinPair::checkMinPair() {
        
          // quick check if adding follows ascending order and one was already
          // added
        if (pairsAddedInAscOrder && minPair_s1 != NULL) {
            return;
        }
          // check if first call
        if ( minPair_s1 == NULL ) 
        {
              // set up pointer
            minPair_s1 = lastAdded_s1->clone();
            minPair_s2 = lastAdded_s2->clone();
              // set pointer to smaller of both
            minPair_max = (minPair_s1->operator <(*minPair_s2))?minPair_s1:minPair_s2;
            return;
        }
          // get max of the last added pair
        const State* lastMax = (lastAdded_s1->operator <(*lastAdded_s2))?lastAdded_s1:lastAdded_s2;
          // check if max of last added pair is smaller minPair max
        if ( lastMax->operator <(*minPair_max)) {
              // set up pointer
            minPair_s1 = lastAdded_s1->clone(minPair_s1);
            minPair_s2 = lastAdded_s2->clone(minPair_s2);
              // set pointer to smaller of both
            minPair_max = (lastMax==lastAdded_s1)?minPair_s1:minPair_s2;
        }
    }

} // namespace ell


//##############################################################################
//##############################################################################