indexHolder.h

Go to the documentation of this file.

 
#ifndef __INDEX_HOLDER_H_
#define __INDEX_HOLDER_H_
 
#include <iostream>
 
template <typename T> 
class IndexHolder {
  public:
    unsigned long       index;
    T                     value;
 
    IndexHolder() {
      value = T();
      index = 0;
    };
    IndexHolder(T  v, unsigned long i) { value = v; index = i;};
    IndexHolder(const IndexHolder<T>& rhs) {
      value = rhs.value;
      index = rhs.index;
    };
 
    ~IndexHolder() {};
    
 
    
 
    static bool lessThan (const IndexHolder<T>& a, const IndexHolder<T>& b) {
      return a < b;
    }
 
    IndexHolder<T>& operator= (const IndexHolder<T>& other) {
      if ( this != &other ) {
        value = other.value;
        index = other.index;
      }
 
      return *this;
    }
    
    friend std::ostream& operator<<(std::ostream& os, const IndexHolder& dt) {
      os << "idx-hldr: " << dt.value << ":" << dt.index << std::endl;
      return os;
    }
 
    
    bool  operator < ( IndexHolder<T> const  &other) const {
      if ( value == other.value ) 
        return (index < other.index );
      else
        return ( value < other.value );
    }
 
    bool  operator > ( IndexHolder<T> const  &other) const {
      if ( value == other.value ) 
        return (index > other.index );
      else
        return ( value > other.value );
    }
 
    bool  operator <= ( IndexHolder<T> const  &other) const {
      if ( value == other.value ) 
        return (index <= other.index );
      else
        return ( value <=  other.value );
    }
 
    bool  operator >= ( IndexHolder<T> const  &other) const {
      if ( value == other.value ) 
        return (index >= other.index );
      else
        return ( value >= other.value );
    }
 
    bool  operator == ( IndexHolder<T> const  &other) const {
      return ( ( value == other.value ) && (index == other.index) );
    }
 
    bool  operator != ( IndexHolder<T> const  &other) const {
      return (  ( value != other.value) || (index != other.index) );
    }
 
};
 
 
namespace par {
 
  //Forward Declaration
  template <typename T>
    class Mpi_datatype;
 
  template <typename T>
    class Mpi_datatype<IndexHolder<T> > {
      public:
        static MPI_Datatype value()
        {
          static bool         first = true;
          static MPI_Datatype datatype;
 
          if (first) { 
            /*
            IndexHolder<T> test;
 
            first = false;
            int block[2];  
            MPI_Aint disp[2];
            MPI_Datatype type[2];
 
            block[0] = 1;
            block[0] = 1;
            type[0] = MPI_LONG;
            type[1] = Mpi_datatype<T>::value(); 
            disp[0] = 0; 
            disp[1] = sizeof(long);  // sizeof(unsigned long); 
*/
            MPI_Type_contiguous(sizeof(IndexHolder<T>), MPI_BYTE, &datatype);
            // MPI_Type_create_struct(2, block, disp, type, &datatype);
            MPI_Type_commit(&datatype);
          }
 
          return datatype;
        }
    };
 
}//end namespace par
 
 
#endif