SimObjectIDSortedVector.cpp

Go to the documentation of this file.

#include "SimObjectIDSortedVector.h"

#include <algorithm>
#include <numeric>

using std::transform;
using std::sort;
using std::find_if;
using std::partial_sum;


class SimObjectIDLessThan {
public: 
        SimObjectIDLessThan(const vector<SimObject::ID::Packed> & vec )
                : vec(vec)
        {};

        bool operator()(const unsigned idx1,const unsigned idx2)
        {
                if (((SimObject::ID)vec[idx1]).node == ((SimObject::ID)vec[idx2]).node) {
                        if (((SimObject::ID)vec[idx1]).eng == ((SimObject::ID)vec[idx2]).eng) {
                                if (((SimObject::ID)vec[idx1]).type == ((SimObject::ID)vec[idx2]).type) {
                                        return ((SimObject::ID)vec[idx1]).localid < ((SimObject::ID)vec[idx2]).localid;
                                }       
                                return ((SimObject::ID)vec[idx1]).type < ((SimObject::ID)vec[idx2]).type;
                        }
                        return ((SimObject::ID)vec[idx1]).eng < ((SimObject::ID)vec[idx2]).eng;
                }
                return ((SimObject::ID)vec[idx1]).node < ((SimObject::ID)vec[idx2]).node;
        };
         
protected:
        const vector<SimObject::ID::Packed> & vec;      
};


class IDhasNode {
public:
        IDhasNode(nodeid_t localnode, vector< SimObject::ID::Packed > vec, bool predicate_value) :
                predicate_value(predicate_value), localnode(localnode), vec(vec) {};
        
        bool operator() (const unsigned idx) {
                if (predicate_value)
                        return ((SimObject::ID)vec[idx]).node == localnode;
                else 
                        return ((SimObject::ID)vec[idx]).node != localnode;
        }

protected:
        bool predicate_value;
        nodeid_t localnode;
        vector<SimObject::ID::Packed> &vec;
};


SimObjectIDSortedVector::SimObjectIDSortedVector(const SimObject::ID::Vector &v, const nodeid_t localnode, bool sorted)
{
        init(&(*v), localnode, sorted);
}


SimObjectIDSortedVector::SimObjectIDSortedVector(const vector<SimObject::ID::Packed> &v, const nodeid_t localnode, bool sorted)
{
        init(&v,localnode, sorted);     
}

void SimObjectIDSortedVector::init(const vector<SimObject::ID::Packed> *v, const nodeid_t localnode, bool sorted) 
{
        vec = v;        
        index_vec.resize(v->size(), unsigned(1));
        index_vec[0] = 0;
        partial_sum(index_vec.begin(), index_vec.end(), index_vec.begin());
        if (sorted) {
                sort(index_vec.begin(), index_vec.end(), SimObjectIDLessThan(*v));
                localids_begin_it = find_if(index_vec.begin(), index_vec.end(), IDhasNode(localnode, *vec, true));              
                localids_end_it = find_if(localids_begin_it, index_vec.end(), IDhasNode(localnode, *vec, false));
                begin_it = index_vec.begin();
        }
}
SimObjectIDSortedVector::~SimObjectIDSortedVector()
{
        
}
        
SimObjectIDSortedVector::const_iterator SimObjectIDSortedVector::beginBlock()
{
        return begin_it;
}
        
SimObjectIDSortedVector::const_iterator SimObjectIDSortedVector::endBlock()
{
        return end_it;
}

void SimObjectIDSortedVector::startBlockIteration()
{
        end_it = index_vec.begin();
}

void SimObjectIDSortedVector::startBlockIterationFromLocal()
{
        end_it = localids_end_it;
        begin_it = localids_begin_it;   
}

        
nodeid_t SimObjectIDSortedVector::nextBlock()
{
        begin_it = end_it;
        nodeid_t prev_node = ((SimObject::ID)((*vec)[*end_it])).node;
        while (end_it != index_vec.end() && ((SimObject::ID)((*vec)[*end_it])).node == prev_node) 
                ++end_it;               
        return ((SimObject::ID)((*vec)[*begin_it])).node;
}

SimObjectIDSortedVector::const_iterator SimObjectIDSortedVector::localIDsBegin()
{
        return localids_begin_it;
}

SimObjectIDSortedVector::const_iterator SimObjectIDSortedVector::localIDsEnd()
{
        return localids_end_it; 
}

        
bool SimObjectIDSortedVector::hasNextBlock()
{
        return end_it != index_vec.end();       
}
        

---