MPI_View.h

#ifndef MPI_View_H
#define MPI_View_H
 
//inherited class object
#include "MPI_Object.h"
 
//MPI types header
#include "MPI_Type.h"
 
class MPI_View  : public MPI_Object {
   
    //attributes
private :
 
    tMPIIOIndex mStart;
    tMPIType mType;//type of the initial element used to make the view
    tMPIView mView;
    tBoolean mIsRegistered;
    
public:
    // CONSTRUCTORS
    
    MPI_View() {
        mIsRegistered=false;
    }
  
 
    // DESTRUCTORS 
    virtual ~MPI_View(void) {
        if (mIsRegistered) MPI_Type::Unregister(mView);
           
   
    }
 
public:
    //New methods
    //------------
    inline static CORE_UniquePointer<MPI_View> New() {
        CORE_UniquePointer<MPI_View> p(new MPI_View(),
                                       MPI_View::Delete());
        
        return p;
    };
    
public:
    
 
    //ACCESSORS methods
    //================
 
    inline const tMPIIOIndex& getStartIndex() const {
        return mStart;
    }
    inline const tMPIType& getType() const {
        return mType;
    }
    inline const tMPIView& getMPIView() const {
        return mView;
    }
 
     
    template<int N,typename T>
    inline tBoolean createSubArrayView(const std::array<int,N>& arraySize,
                                       const std::array<int,N>& startElement,
                                       const std::array<int,N>& subarraySize) {
        mType=MPI_Type::GetPrimaryType<T>();
        if (mIsRegistered) {
            mIsRegistered=false;
            MPI_Type::Unregister(mView);
        }
        tBoolean ret=(MPI_Type_create_subarray(N,arraySize.data(),subarraySize.data(),startElement.data(),MPI_ORDER_C,mType,&mView)==MPI_SUCCESS);
 
        MPI_Type::Register(mView);
        mIsRegistered=true;
        return ret;
    }
 
 
    template<typename T>
    inline tBoolean createVariableStepView(const tMPICount& nElements,
                                           const std::valarray<tMPICount>& elementSizes,
                                           const std::valarray<tMPICount>& elementIndices) {
        if (mIsRegistered) {
            mIsRegistered=false;
            MPI_Type::Unregister(mView);
        }
          
        //create a type with holes
        tBoolean ret=(MPI_Type::CreateVariableStepType<T>(nElements,elementSizes,elementIndices,mType)==MPI_SUCCESS);
 
        //resize the type 
        //size of type Y
        int sizeofT;
        MPI_Type::GetSize<T>(sizeofT);
        
        //get the lower bp=bound & the extent of type
        tMPIByte lb,extent;
        MPI_Type::GetExtent(mType,lb,extent);
 
        //add one T elements  size
        extent+=sizeofT;
        MPI_Type::Resize(mType,lb,extent,mView);
 
        //update the original type of the original element of the view
        mType=MPI_Type::GetPrimaryType<T>();
        
        //register the view
        MPI_Type::Register(mView);
        mIsRegistered=true;
        
        return ret;
        
    }
    
};
 
 
#endif