MPI_IOFile.h

#ifndef MPI_IOFile_H
#define MPI_IOFile_H
 
//inherited class object
#include "MPI_Object.h"
 
//environment header
#include  "MPI_Environment.h"
 
//MPI types header
#include "MPI_Type.h"
 
//MPI error management header
#include "MPI_Error.h"
 
//view header
#include "MPI_View.h"
 
class MPI_IOFile  : public MPI_Object {
    
    //attributes
public:
    static const tMPIIOMode READ_ONLY=MPI_MODE_RDONLY;
    static const tMPIIOMode WRITE_ONLY=MPI_MODE_WRONLY;
    static const tMPIIOMode READ_WRITE=MPI_MODE_RDWR;
    static const tMPIIOMode CREATE=MPI_MODE_CREATE;
    static const tMPIErrorMode FATAL_ERROR;
    static const tMPIErrorMode RETURN_ERROR;
    
private :
 
    //name of the file
    tString mFileName;
    //file descriport
    tMPIIOFile mFile;
    //error afer instructions
    tMPIError mError;
    
public:
    // CONSTRUCTORS
    
    MPI_IOFile() {
        
    }
  
 
    // DESTRUCTORS 
    virtual ~MPI_IOFile(void) {
      
   
    }
public:
    virtual tMemSize getMemorySize() const override{
        return sizeof(*this)+getContentsMemorySize();
    }
public:
    //New methods
    //------------
    inline static CORE_UniquePointer<MPI_IOFile> New() {
        CORE_UniquePointer<MPI_IOFile> p(new MPI_IOFile(),
                                       MPI_IOFile::Delete());
        
        return p;
    };
    
public:
 
public:
 
    //accessor
    //=========
   
    inline void setFileName(const tString& fn)  {
        mFileName=fn;
 
    }
    inline const tString& getFileName() const {
        return mFileName;
    }
    inline const tMPIError& getError() const {
        return mError;
    }
 
    inline tMPIError setView(const MPI_View& view) {
        return MPI_File_set_view(mFile,0,view.getType(),view.getMPIView(),"native",MPI_INFO_NULL);
    }
    inline tMPIError setView(const tMPIIOIndex& index,const MPI_View& view) {
        return MPI_File_set_view(mFile,index,view.getType(),view.getMPIView(),"native",MPI_INFO_NULL);
    }
    
    //opening & closing
    //=================
    
    inline tBoolean open(const MPI_Environment& env,const tMPIIOMode& mode)   {
        
        mError=MPI_File_open(env.getWorld(),mFileName.c_str(),mode,MPI_INFO_NULL,&mFile);
        return (mError==MPI_SUCCESS);
 
    }
    
    inline static tBoolean Open(const MPI_Environment& env,
                                const tString& fn,const tMPIIOMode& mode,
                                tMPIIOFile& fdesc)  {
        return (MPI_File_open(env.getWorld(),fn.c_str(),mode,MPI_INFO_NULL,&fdesc)==MPI_SUCCESS);
 
    }
 
    inline static tMPIError Close(tMPIIOFile& f) {
        return MPI_File_close(&f);
    }
    inline tBoolean close() {
       mError=MPI_File_close(&mFile);
       return (mError==MPI_SUCCESS);
    }
 
    //write methods
    //============
 
    template<typename T>
    inline tBoolean writeAt(const tMPIIOIndex& pos,const std::valarray<T>& values,tMPIStatus& status) {
        mError=MPI_File_write_at(mFile,pos,&values[0],values.size(),MPI_Type::GetPrimaryType<T>(),&status);
        return (mError==MPI_SUCCESS);
    }
    template<typename T>
    inline tBoolean iWriteAt(const tMPIIOIndex& pos,const std::valarray<T>& values,tMPIStatus& status) {
        mError=MPI_File_iwrite_at(mFile,pos,&values[0],values.size(),MPI_Type::GetPrimaryType<T>(),&status);
        return (mError==MPI_SUCCESS);
    }
 
      
    template<typename T>
    inline tBoolean writeAll(const std::valarray<T>& values,tMPIStatus& status) {
        mError=MPI_File_write_all(mFile,&values[0],values.size(),MPI_Type::GetPrimaryType<T>(),&status);
        return (mError==MPI_SUCCESS);
    }
    inline tBoolean writeOrdered(const tString& str) {
        std::valarray<tUChar> values;
        values.resize(str.length());
        memcpy(&values[0],str.c_str(),sizeof(tUChar)*values.size());
        mError=MPI_File_write_ordered(mFile,&values[0],values.size(),MPI_Type::GetPrimaryType<tUChar>(),MPI_STATUS_IGNORE);
        return (mError==MPI_SUCCESS);
      
    }
    template<typename T>
    inline tBoolean writeOrdered(const std::valarray<T>& values) {
        mError=MPI_File_write_ordered(mFile,&values[0],values.size(),MPI_Type::GetPrimaryType<T>(),MPI_STATUS_IGNORE);
        return (mError==MPI_SUCCESS);
      
    }
    
    
    template<typename T>
    inline tBoolean allWriteAt(const tMPIIOIndex& pos,const std::valarray<T>& values,tMPIStatus& status) {
        mError=MPI_File_write_at_all(mFile,pos,&values[0],values.size(),MPI_Type::GetPrimaryType<T>(),&status);
        return (mError==MPI_SUCCESS);
    }
    template<typename T>
    inline tBoolean iAllWriteAt(const tMPIIOIndex& pos,const std::valarray<T>& values,tMPIStatus& status) {
        mError=MPI_File_iwrite_at_all(mFile,pos,&values[0],values.size(),MPI_Type::GetPrimaryType<T>(),&status);
        return (mError==MPI_SUCCESS);
    }
    
    //read methods
    //============
 
    template<typename T>
    inline tBoolean readAt(const tMPIIOIndex& pos,std::valarray<T>& values,tMPIStatus& status) {
        mError=MPI_File_read_at(mFile,pos,&values[0],values.size(),MPI_Type::GetPrimaryType<T>(),&status);
        return (mError==MPI_SUCCESS);
    }
    
    template<typename T>
    inline tBoolean iReadAt(const tMPIIOIndex& pos,std::valarray<T>& values,tMPIRequest& request) {
        mError=MPI_File_iread_at(mFile,pos,&values[0],values.size(),MPI_Type::GetPrimaryType<T>(),&request);
        return (mError==MPI_SUCCESS);
    }
    
    template<typename T>
    inline tBoolean read(const tMPICount& n,T* values,tMPIStatus& status) {
        mError=MPI_File_read(mFile,values,n,MPI_Type::GetPrimaryType<T>(),&status);
        return (mError==MPI_SUCCESS);
    }
    
    template<typename T>
    inline tBoolean iRead(const tMPICount& n,T* values,tMPIRequest& request) {
        mError=MPI_File_iread(mFile,values,n,MPI_Type::GetPrimaryType<T>(),&request);
        return (mError==MPI_SUCCESS);
    }
 
 
    
    template<typename T>
    inline tBoolean allReadAt(const tMPIIOIndex& pos,std::valarray<T>& values,tMPIStatus& status) {
        mError=MPI_File_read_at_all(mFile,pos,&values[0],values.size(),MPI_Type::GetPrimaryType<T>(),&status);
        return (mError==MPI_SUCCESS);
    }
    template<typename T>
    inline tBoolean iAllReadAt(const tMPIIOIndex& pos,std::valarray<T>& values,tMPIRequest& request) {
        mError=MPI_File_iread_at_all(mFile,pos,&values[0],values.size(),MPI_Type::GetPrimaryType<T>(),&request);
        return (mError==MPI_SUCCESS);
    }
  
    template<typename T>
    inline tBoolean allRead(const tMPICount& n,T* values,tMPIStatus& status) {
        mError=MPI_File_read_all(mFile,values,n,MPI_Type::GetPrimaryType<T>(),&status);
        return (mError==MPI_SUCCESS);
    }
    template<typename T>
    inline tBoolean allRead(std::valarray<T>& values,tMPIStatus& status) {
        mError=MPI_File_read_all(mFile,&values[0],values.size(),MPI_Type::GetPrimaryType<T>(),&status);
        return (mError==MPI_SUCCESS);
    }
    template<typename T>
    inline tBoolean iAllRead(const tMPICount& n,T* values,tMPIRequest& request) {
        mError=MPI_File_iread_all(mFile,values,n,MPI_Type::GetPrimaryType<T>(),&request);
        return (mError==MPI_SUCCESS);
    }
 
    
    template<typename T>
    inline tBoolean sharedRead(const tMPICount& n,T* values,tMPIStatus& status) {
        mError=MPI_File_read_shared(mFile,values,n,MPI_Type::GetPrimaryType<T>(),&status);
        return (mError==MPI_SUCCESS);
    }
    template<typename T>
    inline tBoolean iSharedRead(const tMPICount& n,T* values,tMPIRequest& request) {
        mError=MPI_File_iread_shared(mFile,values,n,MPI_Type::GetPrimaryType<T>(),&request);
        return (mError==MPI_SUCCESS);
    }
    
    template<typename T>
    inline tBoolean orderedRead(const tMPICount& n,T* values,tMPIStatus& status) {
        mError=MPI_File_read_ordered(mFile,values,n,MPI_Type::GetPrimaryType<T>(),&status);
        return (mError==MPI_SUCCESS);
    }
    template<typename T>
    inline tBoolean orderedRead(std::valarray<T>& values,tMPIStatus& status) {
        mError=MPI_File_read_ordered(mFile,values,values.size(),MPI_Type::GetPrimaryType<T>(),&status);
        return (mError==MPI_SUCCESS);
    }
    template<typename T>
    inline tBoolean iOrderedRead(const tMPICount& n,T* values,tMPIRequest& request) {
        mError=MPI_File_iread_ordered(mFile,values,n,MPI_Type::GetPrimaryType<T>(),&request);
        return (mError==MPI_SUCCESS);
    }
 
    //file index management
    //======================
 
    /* \brief get the position of the pointer of the file attached to one core
     * @param[out] pos: core position of the cursor on file
     */
    tBoolean getCorePosition(tMPIIOIndex& pos)  {
        mError=MPI_File_get_position(mFile,&pos);
        return (mError==MPI_SUCCESS);
    }
 
    /* \brief set the position of the pointer of the file attached to one core
     * @param[out] pos: core position of the cursor on file
     */
    tBoolean setCorePosition(const tMPIIOIndex& pos) {
        mError=MPI_File_seek(mFile,pos,MPI_SEEK_SET);
        return (mError==MPI_SUCCESS);
    }
    /* \brief set the position of the pointer of the file attached to one core
     * @param[out] pos: core position of the cursor on file
     */
    tBoolean setCorePositionToEnd() {
        mError=MPI_File_seek(mFile,0,MPI_SEEK_END);
        return (mError==MPI_SUCCESS);
    }
    /* \brief mv the position of the pointer of the file attached to one core with displacement value
     * @param[out] sds: displacement of the cursor on file
     */
    tBoolean moveCorePosition(const tMPIIOIndex& dis) {
        mError=MPI_File_seek(mFile,dis,MPI_SEEK_CUR);
        return (mError==MPI_SUCCESS);
    }
    /* \brief mv the position of the pointer of the file attached to one core with displacement value
     * @param[out] dis: displacement of the cursor on file
     */
    tBoolean moveFromEndCorePosition(const tMPIIOIndex& dis)  {
        mError=MPI_File_seek(mFile,dis,MPI_SEEK_END);
        return (mError==MPI_SUCCESS);
    }
 
    tBoolean getEnvironmentPosition(tMPIIOIndex& pos)  {
        mError=MPI_File_get_position_shared(mFile,&pos);
        return (mError==MPI_SUCCESS);
    }
    
    tBoolean setEnvironmentPosition(const tMPIIOIndex& pos)  {
        mError=MPI_File_seek_shared(mFile,pos,MPI_SEEK_SET);
        return (mError==MPI_SUCCESS);
    }
     /* \brief set the position of the pointer of the file attached to one core
     * @param[out] pos: core position of the cursor on file
     */
    tBoolean setEnvironmentPositionToEnd() {
        mError=MPI_File_seek_shared(mFile,0,MPI_SEEK_END);
        return (mError==MPI_SUCCESS);
    }
    /* \brief mv the position of the pointer of the file attached to one core with displacement value
     * @param[out] dis: displacement of the cursor on file
     */
    tBoolean moveEnvironmentPosition(const tMPIIOIndex& dis) {
        mError=MPI_File_seek_shared(mFile,dis,MPI_SEEK_CUR);
        return (mError==MPI_SUCCESS);
    }
    /* \brief mv the position of the pointer of the file attached to one core with displacement value
     * @param[out] dis: displacement of the cursor on file
     */
    tBoolean moveFromEndEnvironmentPosition(const tMPIIOIndex& dis)  {
        mError=MPI_File_seek_shared(mFile,dis,MPI_SEEK_END);
        return (mError==MPI_SUCCESS);
    }
 
 
    inline tBoolean getSize(tMPIIOIndex& s) const {
        return (MPI_File_get_size(mFile,&s)==MPI_SUCCESS);
    }
 
    
    //error management
    //==================
 
    inline void setErrorMode(const tMPIErrorMode& mode) {
        MPI_File_set_errhandler(mFile,mode);
    }
    inline tString printError() const {
        return MPI_Error::ToString(mError);
    }
 
};
 
 
#endif