/* -*- Mode: C++; c-basic-offset:4 ; -*- */
/*  
 *  (C) 2001 by Argonne National Laboratory.
 *      See COPYRIGHT in top-level directory.
 *
 * This file is automatically generated by buildiface -nosep
 * DO NOT EDIT
 */
/* style: c++ header */

#ifdef MPI
#error "You cannot define MPI; that name is reserved for the MPI namespace"
#endif

// Check for incompatible GCC versions
// GCC (specifically) g++ changed the calling convention
// between 3.2.3 and 3.4.3 (!!)  Normally such changes
// should only occur at major releases (e.g., version 3 to 4)
#ifdef __GNUC__ 
# if __GNUC__ >= 4 
#  if __GNUC_MINOR__ > 2 && 6 == 2 
#  error 'Please use the same version of GCC and g++ for compiling MPICH2 and user MPI programs'
#  endif
# endif     
#endif
// There is a name conflict between stdio.h and iostream (or iostream.h)
// and the MPI C++ binding with respect to the names SEEK_SET, SEEK_CUR, 
// and SEEK_END.  MPI wants these in the MPI namespace, but stdio.h, 
// iostream, or iostream.h will #define these to integer values.  
// #undef'ing these can cause obscure problems.  
#ifndef MPICH_IGNORE_CXX_SEEK

// MPICH_DONT_INCLUDE_STDIO_H is another escape hatch for us, just like
// MPICH_IGNORE_CXX_SEEK.  If we encounter a wacky environment or user in the
// wild that does not want our workaround and/or the stdio.h header, then we can
// offer them a way out.
#ifndef MPICH_DONT_INCLUDE_STDIO_H
// ensure that we have SEEK_* defined
# include <stdio.h>
#endif

enum MPIR_Dummy_seek_type {
    MPIR_DUMMY_SEEK_COMMA_VAL = -1  // permits cleaner comma logic
#ifdef SEEK_SET
    , MPIR_SEEK_SET = SEEK_SET
#   undef SEEK_SET
    , SEEK_SET = MPIR_SEEK_SET
#endif
#ifdef SEEK_CUR
    , MPIR_SEEK_CUR = SEEK_CUR
#   undef SEEK_CUR
    , SEEK_CUR = MPIR_SEEK_CUR
#endif
#ifdef SEEK_END
    , MPIR_SEEK_END = SEEK_END
#   undef SEEK_END
    , SEEK_END = MPIR_SEEK_END
#endif
#ifdef LOCK_SHARED
    , MPIR_LOCK_SHARED = LOCK_SHARED
#   undef LOCK_SHARED
    , LOCK_SHARED = MPIR_LOCK_SHARED
#endif
};

#endif // MPICH_IGNORE_CXX_SEEK
namespace MPI {
#if 1
#define MPIX_CALL( fnc ) \
{int err; err = fnc ; if (err) throw Exception(err);}
#else
#define MPIX_CALL( fnc ) (void)fnc
#endif

// Typedefs for basic int types
typedef MPI_Offset Offset;
typedef MPI_Aint   Aint;
typedef MPI_Fint   Fint;

// Special internal routine
void MPIR_CXX_InitDatatypeNames( void );

// Forward class declarations
class Comm;
class Nullcomm;
class Intercomm;
class Intracomm;
class Cartcomm;
class Graphcomm;

// base (classless) routines
extern     int Detach_buffer( void *&v1 ) ;
extern     bool Is_initialized( void ) ;
extern     void Get_processor_name( char * v1, int &v2 ) ;
extern     void Get_error_string( int v1, char * v2, int &v3 ) ;
extern     void Compute_dims( int v1, int v2, int * v3 ) ;
extern     void Get_version( int &v1, int &v2 ) ;
extern     void Finalize( void ) ;
extern     void Pcontrol( const int v1, ... ) ;
extern     void Attach_buffer( void* v1, int v2 ) ;
extern     int Get_error_class( int v1 ) ;

class Exception  {

  protected:
    int the_real_exception;

  public:
    // new/delete

    inline Exception(int obj) : the_real_exception(obj) {}
    inline Exception(void) : the_real_exception(0) {}

    virtual ~Exception() {}
    // copy/assignment

    Exception(const Exception &obj) : the_real_exception(obj.the_real_exception){}

    Exception& operator=(const Exception &obj) {
      the_real_exception = obj.the_real_exception; return *this; }

    // logical
    bool operator== (const Exception &obj) {
      return (the_real_exception == obj.the_real_exception); }
    bool operator!= (const Exception &obj) {
      return (the_real_exception != obj.the_real_exception); }
    // C/C++ cast and assignment
    inline operator int*() { return &the_real_exception; }
    inline operator int() const { return the_real_exception; }
    Exception& operator=(const int& obj) {
      the_real_exception = obj; return *this; }

  protected:
    char the_error_message[MPI_MAX_ERROR_STRING];
  public:
    int Get_error_code(void) { return the_real_exception; } 
    int Get_error_class(void) { return MPI::Get_error_class(the_real_exception); } 
    const char *Get_error_string(void)
    {
	int len;
	MPI_Error_string(the_real_exception, the_error_message, &len);
	return the_error_message;
    }
};

class Datatype  {
    friend class Comm;
    friend class Status;
    friend class Intracomm;
    friend class Intercomm;
    friend class Win;
    friend class File;
    friend class Op;

  protected:
    MPI_Datatype the_real_datatype;

  public:
    // new/delete

    inline Datatype(MPI_Datatype obj) : the_real_datatype(obj) {}
    inline Datatype(void) : the_real_datatype(MPI_DATATYPE_NULL) {}

    virtual ~Datatype() {}
    // copy/assignment

    Datatype(const Datatype &obj) : the_real_datatype(obj.the_real_datatype){}

    Datatype& operator=(const Datatype &obj) {
      the_real_datatype = obj.the_real_datatype; return *this; }

    // logical
    bool operator== (const Datatype &obj) {
      return (the_real_datatype == obj.the_real_datatype); }
    bool operator!= (const Datatype &obj) {
      return (the_real_datatype != obj.the_real_datatype); }
    // C/C++ cast and assignment
    inline operator MPI_Datatype*() { return &the_real_datatype; }
    inline operator MPI_Datatype() const { return the_real_datatype; }
    Datatype& operator=(const MPI_Datatype& obj) {
      the_real_datatype = obj; return *this; }
    virtual void Commit( void ) 
    {
        MPIX_CALL( MPI_Type_commit( (MPI_Datatype *) &the_real_datatype ));
    }
    virtual void Free( void ) 
    {
        MPIX_CALL( MPI_Type_free( (MPI_Datatype *) &the_real_datatype ));
    }
    virtual Datatype Create_indexed( int v1, const int * v2, const int * v3 ) const
    {
        Datatype v5;
        MPIX_CALL( MPI_Type_indexed( v1, (int *)v2, (int *)v3, (MPI_Datatype) the_real_datatype, &(v5.the_real_datatype) ));
        return v5;
    }
    virtual Datatype Create_contiguous( int v1 ) const
    {
        Datatype v3;
        MPIX_CALL( MPI_Type_contiguous( v1, (MPI_Datatype) the_real_datatype, &(v3.the_real_datatype) ));
        return v3;
    }
    virtual Datatype Create_vector( int v1, int v2, int v3 ) const
    {
        Datatype v5;
        MPIX_CALL( MPI_Type_vector( v1, v2, v3, (MPI_Datatype) the_real_datatype, &(v5.the_real_datatype) ));
        return v5;
    }
    static Datatype Create_struct( int v1, int v2[], MPI_Aint v3[],  const Datatype v4[] ) 
    {
        Datatype v5;
        MPI_Datatype *l4 = new MPI_Datatype[v1];
        { 
            int i4; 
            for (i4=0;i4<v1;i4++) {
                l4[i4] = v4[i4].the_real_datatype;
            }
        }
        MPIX_CALL( MPI_Type_create_struct( v1, (int *)v2, (MPI_Aint *)v3, l4, &(v5.the_real_datatype) ));
                    delete[] l4;
        return v5;
    }
    virtual int Pack_size( int v1, const Comm &v3 ) const;
    virtual void Pack( const void* v1, int v2, void * v4, int v5, int &v6, const Comm &v7 ) const;
    virtual int Get_size( void ) const
    {
        int v2;
        MPIX_CALL( MPI_Type_size( (MPI_Datatype) the_real_datatype, &v2 ));
        return v2;
    }
    virtual void Get_envelope( int &v2, int &v3, int &v4, int &v5 ) const
    {
        MPIX_CALL( MPI_Type_get_envelope( (MPI_Datatype) the_real_datatype, &v2, &v3, &v4, &v5 ));
    }
    virtual Datatype Create_hvector( int v1, int v2, Aint v3 ) const
    {
        Datatype v5;
        MPIX_CALL( MPI_Type_create_hvector( v1, v2, v3, (MPI_Datatype) the_real_datatype, &(v5.the_real_datatype) ));
        return v5;
    }
    static Datatype Match_size( int v1, int v2 ) 
    {
        Datatype v3;
        MPIX_CALL( MPI_Type_match_size( v1, v2, &(v3.the_real_datatype) ));
        return v3;
    }
    virtual Datatype Create_resized( const Aint v2, const Aint v3 ) const
    {
        Datatype v4;
        MPIX_CALL( MPI_Type_create_resized( (MPI_Datatype) the_real_datatype, (MPI_Aint)v2, (MPI_Aint)v3, &(v4.the_real_datatype) ));
        return v4;
    }
    virtual Datatype Create_indexed_block( int v1, int v2, const int v3[] ) const
    {
        Datatype v5;
        MPIX_CALL( MPI_Type_create_indexed_block( v1, v2, (int *)v3, (MPI_Datatype) the_real_datatype, &(v5.the_real_datatype) ));
        return v5;
    }
    virtual Aint Pack_external_size( char * v1, const int v2 ) const
    {
        MPI_Aint v4;
        MPIX_CALL( MPI_Pack_external_size( v1, (int)v2, (MPI_Datatype) the_real_datatype, &v4 ));
        return v4;
    }
    Datatype Dup( void ) const
    {
        Datatype v2;
        MPIX_CALL( MPI_Type_dup( (MPI_Datatype) the_real_datatype, &(v2.the_real_datatype) ));
        return v2;
    }
    virtual Datatype Create_hindexed( int v1, const int v2[], const Aint v3[] ) const
    {
        Datatype v5;
        MPIX_CALL( MPI_Type_create_hindexed( v1, (int *)v2, (MPI_Aint *)v3, (MPI_Datatype) the_real_datatype, &(v5.the_real_datatype) ));
        return v5;
    }
    virtual bool Get_attr( int v2, void * v3 ) const
    {
        int v4;
        MPIX_CALL( MPI_Type_get_attr( (MPI_Datatype) the_real_datatype, v2, v3, &v4 ));
        return v4!= 0;
    }
    virtual void Get_true_extent( Aint & v2, Aint & v3 ) const
    {
        MPIX_CALL( MPI_Type_get_true_extent( (MPI_Datatype) the_real_datatype, &v2, &v3 ));
    }
    virtual Datatype Create_darray( int v1, int v2, int v3, const int v4[], const int v5[], const int v6[], const int v7[], int v8 ) const
    {
        Datatype v10;
        MPIX_CALL( MPI_Type_create_darray( v1, v2, v3, (int *)v4, (int *)v5, (int *)v6, (int *)v7, v8, (MPI_Datatype) the_real_datatype, &(v10.the_real_datatype) ));
        return v10;
    }
    static Datatype Create_f90_real( int v1, int v2 ) 
    {
        Datatype v3;
        MPIX_CALL( MPI_Type_create_f90_real( v1, v2, &(v3.the_real_datatype) ));
        return v3;
    }
    virtual void Get_contents( int v2, int v3, int v4, int v5[], MPI_Aint v6[], Datatype v7[] ) const
    {
        MPI_Datatype *l7 = new MPI_Datatype[v4];
        MPIX_CALL( MPI_Type_get_contents( (MPI_Datatype) the_real_datatype, v2, v3, v4, v5, v6, l7 ));
        { 
            int i7; 
            for (i7=0;i7<v4;i7++) {
                v7[i7].the_real_datatype = l7[i7];
            }
            delete[] l7;
        }
    }
    virtual void Set_attr( int v2, const void * v3 ) 
    {
        MPIX_CALL( MPI_Type_set_attr( (MPI_Datatype) the_real_datatype, v2, (void *)v3 ));
    }
    virtual void Set_name( const char * v2 ) 
    {
        MPIX_CALL( MPI_Type_set_name( (MPI_Datatype) the_real_datatype, (char *)v2 ));
    }
    static Datatype Create_f90_complex( int v1, int v2 ) 
    {
        Datatype v3;
        MPIX_CALL( MPI_Type_create_f90_complex( v1, v2, &(v3.the_real_datatype) ));
        return v3;
    }
    virtual Datatype Create_subarray( int v1, int v2[], const int v3[], const int v4[], const int v5 ) const
    {
        Datatype v7;
        MPIX_CALL( MPI_Type_create_subarray( v1, v2, (int *)v3, (int *)v4, (int)v5, (MPI_Datatype) the_real_datatype, &(v7.the_real_datatype) ));
        return v7;
    }
    virtual void Unpack_external( char * v1, const void * v2, const Aint v3, Aint & v4, void * v5, int v6 ) const
    {
        MPIX_CALL( MPI_Unpack_external( v1, (void *)v2, (MPI_Aint)v3, &v4, v5, v6, (MPI_Datatype) the_real_datatype ));
    }
    static void Free_keyval( int &v1 ) 
    {
        MPIX_CALL( MPI_Type_free_keyval( &v1 ));
    }
    static Datatype Create_struct( int v1, const int v2[], const Aint v3[],  const Datatype v4[] ) 
    {
        Datatype v5;
        MPI_Datatype *l4 = new MPI_Datatype[v1];
        { 
            int i4; 
            for (i4=0;i4<v1;i4++) {
                l4[i4] = v4[i4].the_real_datatype;
            }
        }
        MPIX_CALL( MPI_Type_create_struct( v1, (int *)v2, (MPI_Aint *)v3, l4, &(v5.the_real_datatype) ));
                    delete[] l4;
        return v5;
    }
    static Datatype Create_f90_integer( int v1 ) 
    {
        Datatype v2;
        MPIX_CALL( MPI_Type_create_f90_integer( v1, &(v2.the_real_datatype) ));
        return v2;
    }
    virtual void Pack_external( char * v1, const void * v2, const int v3, void * v5, Aint v6, Aint & v7 ) const
    {
        MPIX_CALL( MPI_Pack_external( v1, (void *)v2, (int)v3, (MPI_Datatype) the_real_datatype, v5, v6, &v7 ));
    }
    virtual void Get_extent( Aint & v2, Aint & v3 ) const
    {
        MPIX_CALL( MPI_Type_get_extent( (MPI_Datatype) the_real_datatype, &v2, &v3 ));
    }
    virtual void Delete_attr( int v2 ) 
    {
        MPIX_CALL( MPI_Type_delete_attr( (MPI_Datatype) the_real_datatype, v2 ));
    }
    virtual void Get_name( char * v2, int &v3 ) const
    {
    MPIR_CXX_InitDatatypeNames();
        MPIX_CALL( MPI_Type_get_name( (MPI_Datatype) the_real_datatype, v2, &v3 ));
    }

    void Unpack( const void *, int, void *, int, int &, const Comm & ) const;

    typedef int Copy_attr_function(const Datatype& oldtype, int type_keyval, void* extra_state, void* attribute_val_in, void* attribute_val_out, bool& flag); 
    typedef int Delete_attr_function(Datatype& type, int type_keyval, void* attribute_val, void* extra_state); 

    static int Create_keyval( Copy_attr_function *, Delete_attr_function *,
                              void * );
    // These functions are *not* part of MPI-2 but are provided
    // because they should have been included
    static int NULL_COPY_FN( const Datatype &oldtype, int keyval, void *ex,
    void *attr_in, void *attr_out, bool &flag ) { flag = 1; return 0;}
    static int NULL_DELETE_FN( Datatype &type, int keyval, void * attr, 
         void *ex ) { return 0; }
    static int DUP_FN( const Datatype &oldtype, int keyval, void *ex,
    void *attr_in, void *attr_out, bool &flag ) { flag = 1; 
    *(void **)attr_out = attr_in; return 0;} 
          

};

    typedef void User_function(const void *, void*, int, const Datatype&); 

class Info  {
    friend class File;
    friend class Win;
    friend class Comm;
    friend class Intracomm;

  protected:
    MPI_Info the_real_info;

  public:
    // new/delete

    inline Info(MPI_Info obj) : the_real_info(obj) {}
    inline Info(void) : the_real_info(MPI_INFO_NULL) {}

    virtual ~Info() {}
    // copy/assignment

    Info(const Info &obj) : the_real_info(obj.the_real_info){}

    Info& operator=(const Info &obj) {
      the_real_info = obj.the_real_info; return *this; }

    // logical
    bool operator== (const Info &obj) {
      return (the_real_info == obj.the_real_info); }
    bool operator!= (const Info &obj) {
      return (the_real_info != obj.the_real_info); }
    // C/C++ cast and assignment
    inline operator MPI_Info*() { return &the_real_info; }
    inline operator MPI_Info() const { return the_real_info; }
    Info& operator=(const MPI_Info& obj) {
      the_real_info = obj; return *this; }
    virtual void Delete( const char * v2 ) 
    {
        MPIX_CALL( MPI_Info_delete( (MPI_Info) the_real_info, (char *)v2 ));
    }
    virtual void Get_nthkey( int v2, char * v3 ) const
    {
        MPIX_CALL( MPI_Info_get_nthkey( (MPI_Info) the_real_info, v2, v3 ));
    }
    virtual void Free( void ) 
    {
        MPIX_CALL( MPI_Info_free( (MPI_Info *) &the_real_info ));
    }
    static Info Create( void ) 
    {
        Info v1;
        MPIX_CALL( MPI_Info_create( &(v1.the_real_info) ));
        return v1;
    }
    virtual void Set( const char * v2, const char * v3 ) 
    {
        MPIX_CALL( MPI_Info_set( (MPI_Info) the_real_info, (char *)v2, (char *)v3 ));
    }
    Info Dup( void ) const
    {
        Info v2;
        MPIX_CALL( MPI_Info_dup( (MPI_Info) the_real_info, &(v2.the_real_info) ));
        return v2;
    }
    virtual bool Get_valuelen( const char * v2, int &v3 ) const
    {
        int v4;
        MPIX_CALL( MPI_Info_get_valuelen( (MPI_Info) the_real_info, (char *)v2, &v3, &v4 ));
        return v4!= 0;
    }
    virtual bool Get( const char * v2, int v3, char * v4 ) const
    {
        int v5;
        MPIX_CALL( MPI_Info_get( (MPI_Info) the_real_info, (char *)v2, v3, v4, &v5 ));
        return v5!= 0;
    }
    virtual int Get_nkeys( void ) const
    {
        int v2;
        MPIX_CALL( MPI_Info_get_nkeys( (MPI_Info) the_real_info, &v2 ));
        return v2;
    }
};

class Status  {
    friend class Comm;
    friend class File;
    friend class Request;

  protected:
    MPI_Status the_real_status;

  public:
    // new/delete

    inline Status(MPI_Status obj) : the_real_status(obj) {}
    inline Status(void) : the_real_status() {}

    virtual ~Status() {}
    // copy/assignment

    Status(const Status &obj) : the_real_status(obj.the_real_status){}

    Status& operator=(const Status &obj) {
      the_real_status = obj.the_real_status; return *this; }

    // C/C++ cast and assignment
    inline operator MPI_Status*() { return &the_real_status; }
    inline operator MPI_Status() const { return the_real_status; }
    Status& operator=(const MPI_Status& obj) {
      the_real_status = obj; return *this; }
    virtual bool Is_cancelled( void ) const
    {
        int v2;
        MPIX_CALL( MPI_Test_cancelled( (MPI_Status *) &the_real_status, &v2 ));
        return v2!= 0;
    }
    virtual int Get_elements( const Datatype &v2 ) const
    {
        int v3;
        MPIX_CALL( MPI_Get_elements( (MPI_Status *) &the_real_status, (MPI_Datatype)(v2.the_real_datatype), &v3 ));
        return v3;
    }
    virtual int Get_count( const Datatype &v2 ) const
    {
        int v3;
        MPIX_CALL( MPI_Get_count( (MPI_Status *) &the_real_status, (MPI_Datatype)(v2.the_real_datatype), &v3 ));
        return v3;
    }
    virtual void Set_cancelled( bool v2 ) 
    {
        int l2;
         l2 = (v2 == true) ? 1 : 0;
        MPIX_CALL( MPI_Status_set_cancelled( (MPI_Status *) &the_real_status, l2 ));
    }
    virtual void Set_elements( const Datatype &v2, int v3 ) 
    {
        MPIX_CALL( MPI_Status_set_elements( (MPI_Status *) &the_real_status, (MPI_Datatype)(v2.the_real_datatype), v3 ));
    }

    int Get_source(void) const { return the_real_status.MPI_SOURCE; }
    int Get_tag(void) const { return the_real_status.MPI_TAG; }
    int Get_error(void) const { return the_real_status.MPI_ERROR; }
    void Set_source(int source) { the_real_status.MPI_SOURCE = source; }
    void Set_tag(int tag) { the_real_status.MPI_TAG = tag; }
    void Set_error(int error) { the_real_status.MPI_ERROR = error; }
};

class Group  {
    friend class Comm;
    friend class Intracomm;
    friend class Intercomm;
    friend class Win;
    friend class File;

  protected:
    MPI_Group the_real_group;

  public:
    // new/delete

    inline Group(MPI_Group obj) : the_real_group(obj) {}
    inline Group(void) : the_real_group(MPI_GROUP_NULL) {}

    virtual ~Group() {}
    // copy/assignment

    Group(const Group &obj) : the_real_group(obj.the_real_group){}

    Group& operator=(const Group &obj) {
      the_real_group = obj.the_real_group; return *this; }

    // logical
    bool operator== (const Group &obj) {
      return (the_real_group == obj.the_real_group); }
    bool operator!= (const Group &obj) {
      return (the_real_group != obj.the_real_group); }
    // C/C++ cast and assignment
    inline operator MPI_Group*() { return &the_real_group; }
    inline operator MPI_Group() const { return the_real_group; }
    Group& operator=(const MPI_Group& obj) {
      the_real_group = obj; return *this; }
    virtual Group Excl( int v2, const int * v3 ) const
    {
        Group v4;
        MPIX_CALL( MPI_Group_excl( (MPI_Group) the_real_group, v2, (int *)v3, &(v4.the_real_group) ));
        return v4;
    }
    virtual int Get_rank( void ) const
    {
        int v2;
        MPIX_CALL( MPI_Group_rank( (MPI_Group) the_real_group, &v2 ));
        return v2;
    }
    virtual void Free( void ) 
    {
        MPIX_CALL( MPI_Group_free( (MPI_Group *) &the_real_group ));
    }
    static Group Union( const Group &v1, const Group &v2 ) 
    {
        Group v3;
        MPIX_CALL( MPI_Group_union( (MPI_Group)(v1.the_real_group), (MPI_Group)(v2.the_real_group), &(v3.the_real_group) ));
        return v3;
    }
    static Group Intersect( const Group &v1, const Group &v2 ) 
    {
        Group v3;
        MPIX_CALL( MPI_Group_intersection( (MPI_Group)(v1.the_real_group), (MPI_Group)(v2.the_real_group), &(v3.the_real_group) ));
        return v3;
    }
    virtual Group Range_excl( int v2, const int v3[][3] ) const
    {
        Group v4;
        MPIX_CALL( MPI_Group_range_excl( (MPI_Group) the_real_group, v2, (int (*)[3])v3, &(v4.the_real_group) ));
        return v4;
    }
    virtual Group Range_incl( int v2, const int v3[][3] ) const
    {
        Group v4;
        MPIX_CALL( MPI_Group_range_incl( (MPI_Group) the_real_group, v2, (int (*)[3])v3, &(v4.the_real_group) ));
        return v4;
    }
    static Group Difference( const Group &v1, const Group &v2 ) 
    {
        Group v3;
        MPIX_CALL( MPI_Group_difference( (MPI_Group)(v1.the_real_group), (MPI_Group)(v2.the_real_group), &(v3.the_real_group) ));
        return v3;
    }
    static void Translate_ranks( const Group &v1, int v2, const int * v3, const Group &v4, int * v5 ) 
    {
        MPIX_CALL( MPI_Group_translate_ranks( (MPI_Group)(v1.the_real_group), v2, (int *)v3, (MPI_Group)(v4.the_real_group), v5 ));
    }
    virtual Group Incl( int v2, const int * v3 ) const
    {
        Group v4;
        MPIX_CALL( MPI_Group_incl( (MPI_Group) the_real_group, v2, (int *)v3, &(v4.the_real_group) ));
        return v4;
    }
    virtual int Get_size( void ) const
    {
        int v2;
        MPIX_CALL( MPI_Group_size( (MPI_Group) the_real_group, &v2 ));
        return v2;
    }
    static int Compare( const Group &v1, const Group &v2 ) 
    {
        int v3;
        MPIX_CALL( MPI_Group_compare( (MPI_Group)(v1.the_real_group), (MPI_Group)(v2.the_real_group), &v3 ));
        return v3;
    }
};

class Op  {
    friend class Intracomm;
    friend class Intercomm;
    friend class Win;
    friend class Comm;

  protected:
    MPI_Op the_real_op;

  public:
    // new/delete

    inline Op(MPI_Op obj) : the_real_op(obj) {}
    inline Op(void) : the_real_op(MPI_OP_NULL) {}

    virtual ~Op() {}
    // copy/assignment

    Op(const Op &obj) : the_real_op(obj.the_real_op){}

    Op& operator=(const Op &obj) {
      the_real_op = obj.the_real_op; return *this; }

    // logical
    bool operator== (const Op &obj) {
      return (the_real_op == obj.the_real_op); }
    bool operator!= (const Op &obj) {
      return (the_real_op != obj.the_real_op); }
    // C/C++ cast and assignment
    inline operator MPI_Op*() { return &the_real_op; }
    inline operator MPI_Op() const { return the_real_op; }
    Op& operator=(const MPI_Op& obj) {
      the_real_op = obj; return *this; }
    virtual void Free( void ) 
    {
        MPIX_CALL( MPI_Op_free( (MPI_Op *) &the_real_op ));
    }
    virtual bool Is_commutative( void )
    {
        int v2;
        MPIX_CALL( MPI_Op_commutative( (MPI_Op) the_real_op, &v2 ));
        return v2!= 0;
    }
    virtual void Reduce_local( void * v1, void * v2, int v3, Datatype v4 )
    {
        MPIX_CALL( MPI_Reduce_local( v1, v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPI_Op) the_real_op ));
    }

    void Init( User_function *, bool );
};

class Errhandler  {
    friend class Comm;
    friend class File;
    friend class Win;

  protected:
    MPI_Errhandler the_real_errhandler;

  public:
    // new/delete

    inline Errhandler(MPI_Errhandler obj) : the_real_errhandler(obj) {}
    inline Errhandler(void) : the_real_errhandler(MPI_ERRHANDLER_NULL) {}

    virtual ~Errhandler() {}
    // copy/assignment

    Errhandler(const Errhandler &obj) : the_real_errhandler(obj.the_real_errhandler){}

    Errhandler& operator=(const Errhandler &obj) {
      the_real_errhandler = obj.the_real_errhandler; return *this; }

    // logical
    bool operator== (const Errhandler &obj) {
      return (the_real_errhandler == obj.the_real_errhandler); }
    bool operator!= (const Errhandler &obj) {
      return (the_real_errhandler != obj.the_real_errhandler); }
    // C/C++ cast and assignment
    inline operator MPI_Errhandler*() { return &the_real_errhandler; }
    inline operator MPI_Errhandler() const { return the_real_errhandler; }
    Errhandler& operator=(const MPI_Errhandler& obj) {
      the_real_errhandler = obj; return *this; }
    virtual void Free( void ) 
    {
        MPIX_CALL( MPI_Errhandler_free( (MPI_Errhandler *) &the_real_errhandler ));
    }
};

class Request  {
    friend class Comm;
    friend class File;
    friend class Grequest;

  protected:
    MPI_Request the_real_request;

  public:
    // new/delete

    inline Request(MPI_Request obj) : the_real_request(obj) {}
    inline Request(void) : the_real_request(MPI_REQUEST_NULL) {}

    virtual ~Request() {}
    // copy/assignment

    Request(const Request &obj) : the_real_request(obj.the_real_request){}

    Request& operator=(const Request &obj) {
      the_real_request = obj.the_real_request; return *this; }

    // logical
    bool operator== (const Request &obj) {
      return (the_real_request == obj.the_real_request); }
    bool operator!= (const Request &obj) {
      return (the_real_request != obj.the_real_request); }
    // C/C++ cast and assignment
    inline operator MPI_Request*() { return &the_real_request; }
    inline operator MPI_Request() const { return the_real_request; }
    Request& operator=(const MPI_Request& obj) {
      the_real_request = obj; return *this; }
    static bool Testany( int v1, Request v2[], int &v3, Status & v5 ) 
    {
        int v4;
        MPI_Request *l2 = new MPI_Request[v1];
        { 
            int i2; 
            for (i2=0;i2<v1;i2++) {
                l2[i2] = v2[i2].the_real_request;
            }
        }
        MPIX_CALL( MPI_Testany( v1, l2, &v3, &v4, (MPI_Status *)&(v5.the_real_status ) ));
        { 
            int i2; 
            for (i2=0;i2<v1;i2++) {
                v2[i2].the_real_request = l2[i2];
            }
            delete[] l2;
        }
        return v4!= 0;
    }
    static bool Testany( int v1, Request v2[], int &v3 ) 
    {
        int v4;
        MPI_Request *l2 = new MPI_Request[v1];
        { 
            int i2; 
            for (i2=0;i2<v1;i2++) {
                l2[i2] = v2[i2].the_real_request;
            }
        }
        MPIX_CALL( MPI_Testany( v1, l2, &v3, &v4, MPI_STATUS_IGNORE ));
        { 
            int i2; 
            for (i2=0;i2<v1;i2++) {
                v2[i2].the_real_request = l2[i2];
            }
            delete[] l2;
        }
        return v4!= 0;
    }
    static int Waitsome( int v1, Request v2[], int * v4, Status v5[] ) 
    {
        int v3;
        MPI_Request *l2 = new MPI_Request[v1];
        MPI_Status *l5 = new MPI_Status[v1];
        { 
            int i2; 
            for (i2=0;i2<v1;i2++) {
                l2[i2] = v2[i2].the_real_request;
            }
        }
        MPIX_CALL( MPI_Waitsome( v1, l2, &v3, v4, l5 ));
        { 
            int i2; 
            for (i2=0;i2<v1;i2++) {
                v2[i2].the_real_request = l2[i2];
            }
            delete[] l2;
        }
        { 
            int i5; 
            for (i5=0;i5<v1;i5++) {
                v5[i5].the_real_status = l5[i5];
            }
            delete[] l5;
        }
        return v3;
    }
    static int Waitsome( int v1, Request v2[], int * v4 ) 
    {
        int v3;
        MPI_Request *l2 = new MPI_Request[v1];
        { 
            int i2; 
            for (i2=0;i2<v1;i2++) {
                l2[i2] = v2[i2].the_real_request;
            }
        }
        MPIX_CALL( MPI_Waitsome( v1, l2, &v3, v4, MPI_STATUSES_IGNORE ));
        { 
            int i2; 
            for (i2=0;i2<v1;i2++) {
                v2[i2].the_real_request = l2[i2];
            }
            delete[] l2;
        }
        return v3;
    }
    virtual void Free( void ) 
    {
        MPIX_CALL( MPI_Request_free( (MPI_Request *) &the_real_request ));
    }
    static bool Testall( int v1, Request v2[], Status v4[] ) 
    {
        int v3;
        MPI_Request *l2 = new MPI_Request[v1];
        MPI_Status *l4 = new MPI_Status[v1];
        { 
            int i2; 
            for (i2=0;i2<v1;i2++) {
                l2[i2] = v2[i2].the_real_request;
            }
        }
        MPIX_CALL( MPI_Testall( v1, l2, &v3, l4 ));
        { 
            int i2; 
            for (i2=0;i2<v1;i2++) {
                v2[i2].the_real_request = l2[i2];
            }
            delete[] l2;
        }
        { 
            int i4; 
            for (i4=0;i4<v1;i4++) {
                v4[i4].the_real_status = l4[i4];
            }
            delete[] l4;
        }
        return v3!= 0;
    }
    static bool Testall( int v1, Request v2[] ) 
    {
        int v3;
        MPI_Request *l2 = new MPI_Request[v1];
        { 
            int i2; 
            for (i2=0;i2<v1;i2++) {
                l2[i2] = v2[i2].the_real_request;
            }
        }
        MPIX_CALL( MPI_Testall( v1, l2, &v3, MPI_STATUSES_IGNORE ));
        { 
            int i2; 
            for (i2=0;i2<v1;i2++) {
                v2[i2].the_real_request = l2[i2];
            }
            delete[] l2;
        }
        return v3!= 0;
    }
    virtual void Wait( Status & v2 ) 
    {
        MPIX_CALL( MPI_Wait( (MPI_Request *) &the_real_request, (MPI_Status *)&(v2.the_real_status ) ));
    }
    virtual void Wait( void ) 
    {
        MPIX_CALL( MPI_Wait( (MPI_Request *) &the_real_request, MPI_STATUS_IGNORE ));
    }
    static int Testsome( int v1, Request v2[], int * v4, Status v5[] ) 
    {
        int v3;
        MPI_Request *l2 = new MPI_Request[v1];
        MPI_Status *l5 = new MPI_Status[v1];
        { 
            int i2; 
            for (i2=0;i2<v1;i2++) {
                l2[i2] = v2[i2].the_real_request;
            }
        }
        MPIX_CALL( MPI_Testsome( v1, l2, &v3, v4, l5 ));
        { 
            int i2; 
            for (i2=0;i2<v1;i2++) {
                v2[i2].the_real_request = l2[i2];
            }
            delete[] l2;
        }
        { 
            int i5; 
            for (i5=0;i5<v1;i5++) {
                v5[i5].the_real_status = l5[i5];
            }
            delete[] l5;
        }
        return v3;
    }
    static int Testsome( int v1, Request v2[], int * v4 ) 
    {
        int v3;
        MPI_Request *l2 = new MPI_Request[v1];
        { 
            int i2; 
            for (i2=0;i2<v1;i2++) {
                l2[i2] = v2[i2].the_real_request;
            }
        }
        MPIX_CALL( MPI_Testsome( v1, l2, &v3, v4, MPI_STATUSES_IGNORE ));
        { 
            int i2; 
            for (i2=0;i2<v1;i2++) {
                v2[i2].the_real_request = l2[i2];
            }
            delete[] l2;
        }
        return v3;
    }
    static void Waitall( int v1, Request v2[], Status v3[] ) 
    {
        MPI_Request *l2 = new MPI_Request[v1];
        MPI_Status *l3 = new MPI_Status[v1];
        { 
            int i2; 
            for (i2=0;i2<v1;i2++) {
                l2[i2] = v2[i2].the_real_request;
            }
        }
        MPIX_CALL( MPI_Waitall( v1, l2, l3 ));
        { 
            int i2; 
            for (i2=0;i2<v1;i2++) {
                v2[i2].the_real_request = l2[i2];
            }
            delete[] l2;
        }
        { 
            int i3; 
            for (i3=0;i3<v1;i3++) {
                v3[i3].the_real_status = l3[i3];
            }
            delete[] l3;
        }
    }
    static void Waitall( int v1, Request v2[] ) 
    {
        MPI_Request *l2 = new MPI_Request[v1];
        { 
            int i2; 
            for (i2=0;i2<v1;i2++) {
                l2[i2] = v2[i2].the_real_request;
            }
        }
        MPIX_CALL( MPI_Waitall( v1, l2, MPI_STATUSES_IGNORE ));
        { 
            int i2; 
            for (i2=0;i2<v1;i2++) {
                v2[i2].the_real_request = l2[i2];
            }
            delete[] l2;
        }
    }
    static int Waitany( int v1, Request v2[], Status & v4 ) 
    {
        int v3;
        MPI_Request *l2 = new MPI_Request[v1];
        { 
            int i2; 
            for (i2=0;i2<v1;i2++) {
                l2[i2] = v2[i2].the_real_request;
            }
        }
        MPIX_CALL( MPI_Waitany( v1, l2, &v3, (MPI_Status *)&(v4.the_real_status ) ));
        { 
            int i2; 
            for (i2=0;i2<v1;i2++) {
                v2[i2].the_real_request = l2[i2];
            }
            delete[] l2;
        }
        return v3;
    }
    static int Waitany( int v1, Request v2[] ) 
    {
        int v3;
        MPI_Request *l2 = new MPI_Request[v1];
        { 
            int i2; 
            for (i2=0;i2<v1;i2++) {
                l2[i2] = v2[i2].the_real_request;
            }
        }
        MPIX_CALL( MPI_Waitany( v1, l2, &v3, MPI_STATUS_IGNORE ));
        { 
            int i2; 
            for (i2=0;i2<v1;i2++) {
                v2[i2].the_real_request = l2[i2];
            }
            delete[] l2;
        }
        return v3;
    }
    virtual bool Test( Status & v3 ) 
    {
        int v2;
        MPIX_CALL( MPI_Test( (MPI_Request *) &the_real_request, &v2, (MPI_Status *)&(v3.the_real_status ) ));
        return v2!= 0;
    }
    virtual bool Test( void ) 
    {
        int v2;
        MPIX_CALL( MPI_Test( (MPI_Request *) &the_real_request, &v2, MPI_STATUS_IGNORE ));
        return v2!= 0;
    }
    virtual void Cancel( void ) const
    {
        MPIX_CALL( MPI_Cancel( (MPI_Request *) &the_real_request ));
    }
    virtual bool Get_status( Status & v3 ) const
    {
        int v2;
        MPIX_CALL( MPI_Request_get_status( (MPI_Request) the_real_request, &v2, (MPI_Status *)&(v3.the_real_status ) ));
        return v2!= 0;
    }
    virtual bool Get_status( void ) const
    {
        int v2;
        MPIX_CALL( MPI_Request_get_status( (MPI_Request) the_real_request, &v2, MPI_STATUS_IGNORE ));
        return v2!= 0;
    }
};

class Prequest : public Request {

  public:
    // new/delete

    inline Prequest(MPI_Request obj) : Request(obj) {}
    inline Prequest(void) : Request() {}

    virtual ~Prequest() {}
    // copy/assignment

    Prequest(const Prequest &obj) : Request(obj) {}

    Prequest& operator=(const Prequest &obj) {
      the_real_request = obj.the_real_request; return *this; }

    // C/C++ cast and assignment
    inline operator MPI_Request*() { return &the_real_request; }
    inline operator MPI_Request() const { return the_real_request; }
    Prequest& operator=(const MPI_Request& obj) {
      the_real_request = obj; return *this; }
    virtual void Start( void ) 
    {
        MPIX_CALL( MPI_Start( (MPI_Request *) &the_real_request ));
    }
    static void Startall( int v1, Prequest v2[] ) 
    {
        MPI_Request *l2 = new MPI_Request[v1];
        { 
            int i2; 
            for (i2=0;i2<v1;i2++) {
                l2[i2] = v2[i2].the_real_request;
            }
        }
        MPIX_CALL( MPI_Startall( v1, l2 ));
        { 
            int i2; 
            for (i2=0;i2<v1;i2++) {
                v2[i2].the_real_request = l2[i2];
            }
            delete[] l2;
        }
    }
};

class Comm  {
    friend class Cartcomm;
    friend class Intercomm;
    friend class Intracomm;
    friend class Graphcomm;
    friend class Nullcomm;
    friend class Datatype;
    friend class Win;
    friend class File;

  protected:
    MPI_Comm the_real_comm;

  public:
    // new/delete

    inline Comm(MPI_Comm obj) : the_real_comm(obj) {}
    inline Comm(void) : the_real_comm(MPI_COMM_NULL) {}

    virtual ~Comm() {}
    // copy/assignment

    Comm(const Comm &obj) : the_real_comm(obj.the_real_comm){}

    Comm& operator=(const Comm &obj) {
      the_real_comm = obj.the_real_comm; return *this; }

    // logical
    bool operator== (const Comm &obj) {
      return (the_real_comm == obj.the_real_comm); }
    bool operator!= (const Comm &obj) {
      return (the_real_comm != obj.the_real_comm); }
    // C/C++ cast and assignment
    inline operator MPI_Comm*() { return &the_real_comm; }
    inline operator MPI_Comm() const { return the_real_comm; }
    Comm& operator=(const MPI_Comm& obj) {
      the_real_comm = obj; return *this; }
    virtual Group Get_group( void ) const
    {
        Group v2;
        MPIX_CALL( MPI_Comm_group( (MPI_Comm) the_real_comm, &(v2.the_real_group) ));
        return v2;
    }
    virtual int Get_rank( void ) const
    {
        int v2;
        MPIX_CALL( MPI_Comm_rank( (MPI_Comm) the_real_comm, &v2 ));
        return v2;
    }
    virtual Prequest Bsend_init( const void* v1, int v2, const Datatype &v3, int v4, int v5 ) const
    {
        Prequest v7;
        MPIX_CALL( MPI_Bsend_init( (void*)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Comm) the_real_comm, &(v7.the_real_request) ));
        return v7;
    }
    virtual Prequest Ssend_init( const void* v1, int v2, const Datatype &v3, int v4, int v5 ) const
    {
        Prequest v7;
        MPIX_CALL( MPI_Ssend_init( (void*)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Comm) the_real_comm, &(v7.the_real_request) ));
        return v7;
    }
    virtual bool Is_inter( void ) const
    {
        int v2;
        MPIX_CALL( MPI_Comm_test_inter( (MPI_Comm) the_real_comm, &v2 ));
        return v2!= 0;
    }
    virtual Prequest Rsend_init( const void* v1, int v2, const Datatype &v3, int v4, int v5 ) const
    {
        Prequest v7;
        MPIX_CALL( MPI_Rsend_init( (void*)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Comm) the_real_comm, &(v7.the_real_request) ));
        return v7;
    }
    virtual Request Ibsend( const void* v1, int v2, const Datatype &v3, int v4, int v5 ) const
    {
        Request v7;
        MPIX_CALL( MPI_Ibsend( (void*)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Comm) the_real_comm, &(v7.the_real_request) ));
        return v7;
    }
    virtual void Abort( int v2 ) const
    {
        MPIX_CALL( MPI_Abort( (MPI_Comm) the_real_comm, v2 ));
    }
    virtual void Free( void ) 
    {
        MPIX_CALL( MPI_Comm_free( (MPI_Comm *) &the_real_comm ));
    }
    virtual Prequest Send_init( const void* v1, int v2, const Datatype &v3, int v4, int v5 ) const
    {
        Prequest v7;
        MPIX_CALL( MPI_Send_init( (void*)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Comm) the_real_comm, &(v7.the_real_request) ));
        return v7;
    }
    virtual void Recv( void* v1, int v2, const Datatype &v3, int v4, int v5, Status & v7 ) const
    {
        MPIX_CALL( MPI_Recv( v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Comm) the_real_comm, (MPI_Status *)&(v7.the_real_status ) ));
    }
    virtual void Recv( void* v1, int v2, const Datatype &v3, int v4, int v5 ) const
    {
        MPIX_CALL( MPI_Recv( v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Comm) the_real_comm, MPI_STATUS_IGNORE ));
    }
    virtual void Sendrecv( const void * v1, int v2, const Datatype &v3, int v4, int v5, void * v6, int v7, const Datatype &v8, int v9, int v10, Status & v12 ) const
    {
        MPIX_CALL( MPI_Sendrecv( (void *)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, v6, v7, (MPI_Datatype)(v8.the_real_datatype), v9, v10, (MPI_Comm) the_real_comm, (MPI_Status *)&(v12.the_real_status ) ));
    }
    virtual void Sendrecv( const void * v1, int v2, const Datatype &v3, int v4, int v5, void * v6, int v7, const Datatype &v8, int v9, int v10 ) const
    {
        MPIX_CALL( MPI_Sendrecv( (void *)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, v6, v7, (MPI_Datatype)(v8.the_real_datatype), v9, v10, (MPI_Comm) the_real_comm, MPI_STATUS_IGNORE ));
    }
    virtual void Sendrecv_replace( void* v1, int v2, const Datatype &v3, int v4, int v5, int v6, int v7, Status & v9 ) const
    {
        MPIX_CALL( MPI_Sendrecv_replace( v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, v6, v7, (MPI_Comm) the_real_comm, (MPI_Status *)&(v9.the_real_status ) ));
    }
    virtual void Sendrecv_replace( void* v1, int v2, const Datatype &v3, int v4, int v5, int v6, int v7 ) const
    {
        MPIX_CALL( MPI_Sendrecv_replace( v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, v6, v7, (MPI_Comm) the_real_comm, MPI_STATUS_IGNORE ));
    }
    virtual int Get_topology( void ) const
    {
        int v2;
        MPIX_CALL( MPI_Topo_test( (MPI_Comm) the_real_comm, &v2 ));
        return v2;
    }
    virtual Request Isend( const void* v1, int v2, const Datatype &v3, int v4, int v5 ) const
    {
        Request v7;
        MPIX_CALL( MPI_Isend( (void*)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Comm) the_real_comm, &(v7.the_real_request) ));
        return v7;
    }
    virtual void Probe( int v1, int v2, Status & v4 ) const
    {
        MPIX_CALL( MPI_Probe( v1, v2, (MPI_Comm) the_real_comm, (MPI_Status *)&(v4.the_real_status ) ));
    }
    virtual void Probe( int v1, int v2 ) const
    {
        MPIX_CALL( MPI_Probe( v1, v2, (MPI_Comm) the_real_comm, MPI_STATUS_IGNORE ));
    }
    static int Compare( const Comm &v1, const Comm &v2 ) 
    {
        int v3;
        MPIX_CALL( MPI_Comm_compare( (MPI_Comm)(v1.the_real_comm), (MPI_Comm)(v2.the_real_comm), &v3 ));
        return v3;
    }
    virtual int Get_size( void ) const
    {
        int v2;
        MPIX_CALL( MPI_Comm_size( (MPI_Comm) the_real_comm, &v2 ));
        return v2;
    }
    virtual Request Issend( const void* v1, int v2, const Datatype &v3, int v4, int v5 ) const
    {
        Request v7;
        MPIX_CALL( MPI_Issend( (void*)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Comm) the_real_comm, &(v7.the_real_request) ));
        return v7;
    }
    virtual void Set_errhandler( const Errhandler &v2 ) 
    {
        MPIX_CALL( MPI_Comm_set_errhandler( (MPI_Comm) the_real_comm, (MPI_Errhandler)(v2.the_real_errhandler) ));
    }
    virtual void Send( const void* v1, int v2, const Datatype &v3, int v4, int v5 ) const
    {
        MPIX_CALL( MPI_Send( (void*)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Comm) the_real_comm ));
    }
    virtual Request Irsend( const void* v1, int v2, const Datatype &v3, int v4, int v5 ) const
    {
        Request v7;
        MPIX_CALL( MPI_Irsend( (void*)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Comm) the_real_comm, &(v7.the_real_request) ));
        return v7;
    }
    virtual void Ssend( const void* v1, int v2, const Datatype &v3, int v4, int v5 ) const
    {
        MPIX_CALL( MPI_Ssend( (void*)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Comm) the_real_comm ));
    }
    virtual Prequest Recv_init( void* v1, int v2, const Datatype &v3, int v4, int v5 ) const
    {
        Prequest v7;
        MPIX_CALL( MPI_Recv_init( v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Comm) the_real_comm, &(v7.the_real_request) ));
        return v7;
    }
    virtual bool Iprobe( int v1, int v2, Status & v5 ) const
    {
        int v4;
        MPIX_CALL( MPI_Iprobe( v1, v2, (MPI_Comm) the_real_comm, &v4, (MPI_Status *)&(v5.the_real_status ) ));
        return v4!= 0;
    }
    virtual bool Iprobe( int v1, int v2 ) const
    {
        int v4;
        MPIX_CALL( MPI_Iprobe( v1, v2, (MPI_Comm) the_real_comm, &v4, MPI_STATUS_IGNORE ));
        return v4!= 0;
    }
    virtual void Bsend( const void* v1, int v2, const Datatype &v3, int v4, int v5 ) const
    {
        MPIX_CALL( MPI_Bsend( (void*)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Comm) the_real_comm ));
    }
    virtual Request Irecv( void* v1, int v2, const Datatype &v3, int v4, int v5 ) const
    {
        Request v7;
        MPIX_CALL( MPI_Irecv( v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Comm) the_real_comm, &(v7.the_real_request) ));
        return v7;
    }
    virtual Errhandler Get_errhandler( void ) const
    {
        Errhandler v2;
        MPIX_CALL( MPI_Comm_get_errhandler( (MPI_Comm) the_real_comm, &(v2.the_real_errhandler) ));
        return v2;
    }
    virtual void Rsend( const void* v1, int v2, const Datatype &v3, int v4, int v5 ) const
    {
        MPIX_CALL( MPI_Rsend( (void*)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Comm) the_real_comm ));
    }
    virtual void Reduce_scatter_block( const void * v1, void * v2, int v3, const Datatype &v4, const Op &v5 ) const
    {
        MPIX_CALL( MPI_Reduce_scatter_block( (void *)v1, v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPI_Op)(v5.the_real_op), (MPI_Comm) the_real_comm ));
    }
    virtual void Gatherv( const void* v1, int v2, const Datatype &v3, void* v4, const int * v5, const int * v6, const Datatype &v7, int v8 ) const
    {
        MPIX_CALL( MPI_Gatherv( (void*)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, (int *)v5, (int *)v6, (MPI_Datatype)(v7.the_real_datatype), v8, (MPI_Comm) the_real_comm ));
    }
    virtual void Disconnect( void ) 
    {
        MPIX_CALL( MPI_Comm_disconnect( (MPI_Comm *) &the_real_comm ));
    }
    virtual void Allreduce( const void* v1, void* v2, int v3, const Datatype &v4, const Op &v5 ) const
    {
        MPIX_CALL( MPI_Allreduce( (void*)v1, v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPI_Op)(v5.the_real_op), (MPI_Comm) the_real_comm ));
    }
    virtual void Alltoallw( const void * v1, const int v2[], const int v3[],  const Datatype v4[], void * v5, const int v6[], const int v7[],  const Datatype v8[] ) const
    {
        MPI_Datatype *l4 = new MPI_Datatype[Get_size()];
        MPI_Datatype *l8 = new MPI_Datatype[Get_size()];
        { 
            int i4; 
            for (i4=0;i4<Get_size();i4++) {
                l4[i4] = v4[i4].the_real_datatype;
            }
        }
        { 
            int i8; 
            for (i8=0;i8<Get_size();i8++) {
                l8[i8] = v8[i8].the_real_datatype;
            }
        }
        MPIX_CALL( MPI_Alltoallw( (void *)v1, (int *)v2, (int *)v3, l4, v5, (int *)v6, (int *)v7, l8, (MPI_Comm) the_real_comm ));
                    delete[] l4;
                    delete[] l8;
    }
    static Intercomm Join( const int v1 ) ;
    virtual void Alltoall( const void* v1, int v2, const Datatype &v3, void* v4, int v5, const Datatype &v6 ) const
    {
        MPIX_CALL( MPI_Alltoall( (void*)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Datatype)(v6.the_real_datatype), (MPI_Comm) the_real_comm ));
    }
    virtual bool Get_attr( int v2, void * v3 ) const
    {
        int v4;
        MPIX_CALL( MPI_Comm_get_attr( (MPI_Comm) the_real_comm, v2, v3, &v4 ));
        return v4!= 0;
    }
    virtual void Barrier( void ) const
    {
        MPIX_CALL( MPI_Barrier( (MPI_Comm) the_real_comm ));
    }
    virtual void Bcast( void* v1, int v2, const Datatype &v3, int v4 ) const
    {
        MPIX_CALL( MPI_Bcast( v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, (MPI_Comm) the_real_comm ));
    }
    virtual void Set_attr( int v2, const void * v3 ) 
    {
        MPIX_CALL( MPI_Comm_set_attr( (MPI_Comm) the_real_comm, v2, (void *)v3 ));
    }
    virtual void Set_name( const char * v2 ) 
    {
        MPIX_CALL( MPI_Comm_set_name( (MPI_Comm) the_real_comm, (char *)v2 ));
    }
    static Intercomm Get_parent( void ) ;
    virtual void Alltoallv( const void* v1, const int * v2, const int * v3, const Datatype &v4, void* v5, const int * v6, const int * v7, const Datatype &v8 ) const
    {
        MPIX_CALL( MPI_Alltoallv( (void*)v1, (int *)v2, (int *)v3, (MPI_Datatype)(v4.the_real_datatype), v5, (int *)v6, (int *)v7, (MPI_Datatype)(v8.the_real_datatype), (MPI_Comm) the_real_comm ));
    }
    virtual void Reduce_scatter( const void* v1, void* v2, int * v3, const Datatype &v4, const Op &v5 ) const
    {
        MPIX_CALL( MPI_Reduce_scatter( (void*)v1, v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPI_Op)(v5.the_real_op), (MPI_Comm) the_real_comm ));
    }
    virtual void Scatter( const void* v1, int v2, const Datatype &v3, void* v4, int v5, const Datatype &v6, int v7 ) const
    {
        MPIX_CALL( MPI_Scatter( (void*)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Datatype)(v6.the_real_datatype), v7, (MPI_Comm) the_real_comm ));
    }
    virtual void Call_errhandler( int v2 ) const;
    virtual void Gather( const void* v1, int v2, const Datatype &v3, void* v4, int v5, const Datatype &v6, int v7 ) const
    {
        MPIX_CALL( MPI_Gather( (void*)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Datatype)(v6.the_real_datatype), v7, (MPI_Comm) the_real_comm ));
    }
    static void Free_keyval( int &v1 ) 
    {
        MPIX_CALL( MPI_Comm_free_keyval( &v1 ));
    }
    virtual void Reduce( const void* v1, void* v2, int v3, const Datatype &v4, const Op &v5, int v6 ) const
    {
        MPIX_CALL( MPI_Reduce( (void*)v1, v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPI_Op)(v5.the_real_op), v6, (MPI_Comm) the_real_comm ));
    }
    virtual void Allgather( const void* v1, int v2, const Datatype &v3, void* v4, int v5, const Datatype &v6 ) const
    {
        MPIX_CALL( MPI_Allgather( (void*)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, (MPI_Datatype)(v6.the_real_datatype), (MPI_Comm) the_real_comm ));
    }
    virtual void Delete_attr( int v2 ) 
    {
        MPIX_CALL( MPI_Comm_delete_attr( (MPI_Comm) the_real_comm, v2 ));
    }
    virtual void Scatterv( const void* v1, const int * v2, const int * v3, const Datatype &v4, void* v5, int v6, const Datatype &v7, int v8 ) const
    {
        MPIX_CALL( MPI_Scatterv( (void*)v1, (int *)v2, (int *)v3, (MPI_Datatype)(v4.the_real_datatype), v5, v6, (MPI_Datatype)(v7.the_real_datatype), v8, (MPI_Comm) the_real_comm ));
    }
    virtual void Get_name( char * v2, int &v3 ) const
    {
        MPIX_CALL( MPI_Comm_get_name( (MPI_Comm) the_real_comm, v2, &v3 ));
    }
    virtual void Allgatherv( const void* v1, int v2, const Datatype &v3, void* v4, const int * v5, const int * v6, const Datatype &v7 ) const
    {
        MPIX_CALL( MPI_Allgatherv( (void*)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, (int *)v5, (int *)v6, (MPI_Datatype)(v7.the_real_datatype), (MPI_Comm) the_real_comm ));
    }
    virtual Comm &Clone(void) const = 0;
    typedef int Copy_attr_function(const Comm& oldcomm, int comm_keyval, void* extra_state, void* attribute_val_in, void* attribute_val_out, bool& flag); 
    typedef int Delete_attr_function(Comm& comm, int comm_keyval, void* attribute_val, void* extra_state); 
    typedef void Errhandler_function(Comm &, int *, ... );
    typedef Errhandler_function Errhandler_fn;

    static int Create_keyval( Copy_attr_function *, Delete_attr_function *,
                              void * );
          
    static int NULL_COPY_FN( const Comm &oldcomm, int keyval, void *ex,
    void *attr_in, void *attr_out, bool &flag ) { flag = 0; return 0;}
    static int NULL_DELETE_FN( Comm &comm, int keyval, void * attr, void *ex )
	{ return 0; }
    static int DUP_FN( const Comm &oldcomm, int keyval, void *ex,
    void *attr_in, void *attr_out, bool &flag ) { flag = 1; 
    *(void **)attr_out = attr_in; return 0;} 
    static Errhandler Create_errhandler( Errhandler_function * );

};

class Nullcomm : public Comm {

  public:
    // new/delete

    inline Nullcomm(MPI_Comm obj) : Comm(obj) {}
    inline Nullcomm(void) : Comm() {}

    virtual ~Nullcomm() {}
    // copy/assignment

    Nullcomm(const Nullcomm &obj) : Comm(obj) {}

    Nullcomm& operator=(const Nullcomm &obj) {
      the_real_comm = obj.the_real_comm; return *this; }

    // C/C++ cast and assignment
    inline operator MPI_Comm*() { return &the_real_comm; }
    inline operator MPI_Comm() const { return the_real_comm; }
    Nullcomm& operator=(const MPI_Comm& obj) {
      the_real_comm = obj; return *this; }

// If the compiler does not support variable return types, return a 
// reference to Comm.  The user must then cast this to the correct type
// (Standard-conforming C++ compilers support variable return types)
#ifdef HAVE_NO_VARIABLE_RETURN_TYPE_SUPPORT
    virtual Comm & Clone(void) const { 
        Comm *clone = new Nullcomm(MPI_COMM_NULL); 
        return *clone; 
    };
#else
    virtual Nullcomm & Clone(void) const { 
        Nullcomm *clone = new Nullcomm();
        return *clone; 
    };
#endif
};

class Intercomm : public Comm {
    friend class Intracomm;

  public:
    // new/delete

    inline Intercomm(MPI_Comm obj) : Comm(obj) {}
    inline Intercomm(void) : Comm() {}

    virtual ~Intercomm() {}
    // copy/assignment

    Intercomm(const Intercomm &obj) : Comm(obj) {}

    Intercomm& operator=(const Intercomm &obj) {
      the_real_comm = obj.the_real_comm; return *this; }

    // C/C++ cast and assignment
    inline operator MPI_Comm*() { return &the_real_comm; }
    inline operator MPI_Comm() const { return the_real_comm; }
    Intercomm& operator=(const MPI_Comm& obj) {
      the_real_comm = obj; return *this; }
    virtual Intracomm Merge( bool v2 ) const;
    virtual Group Get_remote_group( void ) const
    {
        Group v2;
        MPIX_CALL( MPI_Comm_remote_group( (MPI_Comm) the_real_comm, &(v2.the_real_group) ));
        return v2;
    }
    virtual int Get_remote_size( void ) const
    {
        int v2;
        MPIX_CALL( MPI_Comm_remote_size( (MPI_Comm) the_real_comm, &v2 ));
        return v2;
    }
    Intercomm Dup( void ) const
    {
        Intercomm v2;
        MPIX_CALL( MPI_Comm_dup( (MPI_Comm) the_real_comm, &(v2.the_real_comm) ));
        return v2;
    }
    virtual Intercomm Split( int v2, int v3 ) const
    {
        Intercomm v4;
        MPIX_CALL( MPI_Comm_split( (MPI_Comm) the_real_comm, v2, v3, &(v4.the_real_comm) ));
        return v4;
    }
    
// If the compiler does not support variable return types, return a 
// reference to Comm.  The user must then cast this to the correct type
// (Standard-conforming C++ compilers support variable return types)
#ifdef HAVE_NO_VARIABLE_RETURN_TYPE_SUPPORT
    virtual Comm & Clone(void) const { 
        MPI_Comm ncomm;
        MPI_Comm_dup( (MPI_Comm)the_real_comm, &ncomm); 
        Comm *clone = new Intercomm(ncomm); 
        return *clone; 
    };
#else
    virtual Intercomm & Clone(void) const { 
        MPI_Comm ncomm;
        MPI_Comm_dup( (MPI_Comm)the_real_comm, &ncomm); 
        Intercomm *clone = new Intercomm(ncomm); 
        return *clone; 
    };
#endif
};

class Intracomm : public Comm {
    friend class Cartcomm;
    friend class Graphcomm;
    friend class Datatype;

  public:
    // new/delete

    inline Intracomm(MPI_Comm obj) : Comm(obj) {}
    inline Intracomm(void) : Comm() {}

    virtual ~Intracomm() {}
    // copy/assignment

    Intracomm(const Intracomm &obj) : Comm(obj) {}

    Intracomm& operator=(const Intracomm &obj) {
      the_real_comm = obj.the_real_comm; return *this; }

    // C/C++ cast and assignment
    inline operator MPI_Comm*() { return &the_real_comm; }
    inline operator MPI_Comm() const { return the_real_comm; }
    Intracomm& operator=(const MPI_Comm& obj) {
      the_real_comm = obj; return *this; }
    virtual Intercomm Create_intercomm( int v2, const Comm &v3, int v4, int v5 ) const
    {
        Intercomm v6;
        MPIX_CALL( MPI_Intercomm_create( (MPI_Comm) the_real_comm, v2, (MPI_Comm)(v3.the_real_comm), v4, v5, &(v6.the_real_comm) ));
        return v6;
    }
    virtual Intracomm Split( int v2, int v3 ) const
    {
        Intracomm v4;
        MPIX_CALL( MPI_Comm_split( (MPI_Comm) the_real_comm, v2, v3, &(v4.the_real_comm) ));
        return v4;
    }
    virtual Graphcomm Create_graph( int v2, const int * v3, const int * v4, bool v5 ) const;
    virtual Cartcomm Create_cart( int v2, const int * v3, const bool v4[], bool v5 ) const;
    virtual Intracomm Create( const Group &v2 ) const
    {
        Intracomm v3;
        MPIX_CALL( MPI_Comm_create( (MPI_Comm) the_real_comm, (MPI_Group)(v2.the_real_group), &(v3.the_real_comm) ));
        return v3;
    }
    Intracomm Dup( void ) const
    {
        Intracomm v2;
        MPIX_CALL( MPI_Comm_dup( (MPI_Comm) the_real_comm, &(v2.the_real_comm) ));
        return v2;
    }
    virtual void Scan( const void* v1, void* v2, int v3, const Datatype &v4, const Op &v5 ) const
    {
        MPIX_CALL( MPI_Scan( (void*)v1, v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPI_Op)(v5.the_real_op), (MPI_Comm) the_real_comm ));
    }
    virtual void Exscan( const void * v1, void * v2, int v3, const Datatype &v4, const Op &v5 ) const
    {
        MPIX_CALL( MPI_Exscan( (void *)v1, v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPI_Op)(v5.the_real_op), (MPI_Comm) the_real_comm ));
    }
    virtual Intercomm Accept( const char * v1, const Info &v2, int v3 ) const
    {
        Intercomm v5;
        MPIX_CALL( MPI_Comm_accept( (char *)v1, (MPI_Info)(v2.the_real_info), v3, (MPI_Comm) the_real_comm, &(v5.the_real_comm) ));
        return v5;
    }
    virtual Intercomm Connect( const char * v1, const Info &v2, int v3 ) const
    {
        Intercomm v5;
        MPIX_CALL( MPI_Comm_connect( (char *)v1, (MPI_Info)(v2.the_real_info), v3, (MPI_Comm) the_real_comm, &(v5.the_real_comm) ));
        return v5;
    }
    
// If the compiler does not support variable return types, return a 
// reference to Comm.  The user must then cast this to the correct type
// (Standard-conforming C++ compilers support variable return types)
#ifdef HAVE_NO_VARIABLE_RETURN_TYPE_SUPPORT
    virtual Comm & Clone(void) const { 
        MPI_Comm ncomm;
        MPI_Comm_dup( (MPI_Comm)the_real_comm, &ncomm); 
        Comm *clone = new Intracomm(ncomm); 
        return *clone; 
    };
#else
    virtual Intracomm & Clone(void) const { 
        MPI_Comm ncomm;
        MPI_Comm_dup( (MPI_Comm)the_real_comm, &ncomm); 
        Intracomm *clone = new Intracomm(ncomm); 
        return *clone; 
    };
#endif

Intercomm Spawn(const char* command, const char* argv[], int maxprocs, const MPI::Info& info, int root) const {
    Intercomm ic;
    MPIX_CALL( MPI_Comm_spawn( (char *)command, (char **)argv, 
                maxprocs, info.the_real_info, root, the_real_comm, 
                &(ic.the_real_comm), MPI_ERRCODES_IGNORE ) );
    return ic;
}
Intercomm Spawn(const char* command, const char* argv[], int maxprocs, const MPI::Info& info, int root, int array_of_errcodes[]) const {
    Intercomm ic;
    MPIX_CALL( MPI_Comm_spawn( (char *)command, (char **)argv, 
                maxprocs, info.the_real_info, root, the_real_comm, 
                &(ic.the_real_comm), array_of_errcodes ) );
    return ic;
}
Intercomm Spawn_multiple(int count, const char* array_of_commands[], const char** array_of_argv[], const int array_of_maxprocs[], const MPI::Info array_of_info[], int root) {
    Intercomm ic;
    MPI_Info  *li = new MPI_Info [count];
    int i;
    for (i=0; i<count; i++) {
        li[i] = array_of_info[i].the_real_info;
    }
    MPIX_CALL( MPI_Comm_spawn_multiple( count, (char **)array_of_commands, 
          (char ***)array_of_argv, (int *)array_of_maxprocs, 
                li, root, the_real_comm, &(ic.the_real_comm), 
                MPI_ERRCODES_IGNORE ) );
    delete [] li;
    return ic;
}
Intercomm Spawn_multiple(int count, const char* array_of_commands[], const char** array_of_argv[], const int array_of_maxprocs[], const MPI::Info array_of_info[], int root, int array_of_errcodes[]) {
    Intercomm ic;
    MPI_Info  *li = new MPI_Info [count];
    int i;
    for (i=0; i<count; i++) {
        li[i] = array_of_info[i].the_real_info;
    }
    MPIX_CALL( MPI_Comm_spawn_multiple( count, (char **)array_of_commands, 
          (char ***)array_of_argv, (int *)array_of_maxprocs, 
                li, root, the_real_comm, &(ic.the_real_comm), 
                array_of_errcodes ) );
    delete [] li;
    return ic;
}

};

class Grequest : public Request {

  public:
    // new/delete

    inline Grequest(MPI_Request obj) : Request(obj) {}
    inline Grequest(void) : Request() {}

    virtual ~Grequest() {}
    // copy/assignment

    Grequest(const Grequest &obj) : Request(obj) {}

    Grequest& operator=(const Grequest &obj) {
      the_real_request = obj.the_real_request; return *this; }

    // logical
    bool operator== (const Grequest &obj) {
      return (the_real_request == obj.the_real_request); }
    bool operator!= (const Grequest &obj) {
      return (the_real_request != obj.the_real_request); }
    // C/C++ cast and assignment
    inline operator MPI_Request*() { return &the_real_request; }
    inline operator MPI_Request() const { return the_real_request; }
    Grequest& operator=(const MPI_Request& obj) {
      the_real_request = obj; return *this; }
    virtual void Complete( void ) 
    {
        MPIX_CALL( MPI_Grequest_complete( (MPI_Request) the_real_request ));
    }

    typedef int Query_function( void *, Status & );
    typedef int Free_function( void * );
    typedef int Cancel_function( void *, bool );

    Grequest Start( Query_function  *query_fn,
                    Free_function   *free_fn,
                    Cancel_function *cancel_fn,
                    void *extra_state );
};

class Win  {

  protected:
    MPI_Win the_real_win;

  public:
    // new/delete

    inline Win(MPI_Win obj) : the_real_win(obj) {}
    inline Win(void) : the_real_win(MPI_WIN_NULL) {}

    virtual ~Win() {}
    // copy/assignment

    Win(const Win &obj) : the_real_win(obj.the_real_win){}

    Win& operator=(const Win &obj) {
      the_real_win = obj.the_real_win; return *this; }

    // logical
    bool operator== (const Win &obj) {
      return (the_real_win == obj.the_real_win); }
    bool operator!= (const Win &obj) {
      return (the_real_win != obj.the_real_win); }
    // C/C++ cast and assignment
    inline operator MPI_Win*() { return &the_real_win; }
    inline operator MPI_Win() const { return the_real_win; }
    Win& operator=(const MPI_Win& obj) {
      the_real_win = obj; return *this; }
    virtual Group Get_group( void ) const
    {
        Group v2;
        MPIX_CALL( MPI_Win_get_group( (MPI_Win) the_real_win, &(v2.the_real_group) ));
        return v2;
    }
    virtual void Fence( int v1 ) const
    {
        MPIX_CALL( MPI_Win_fence( v1, (MPI_Win) the_real_win ));
    }
    virtual void Start( const Group &v1, int v2 ) const
    {
        MPIX_CALL( MPI_Win_start( (MPI_Group)(v1.the_real_group), v2, (MPI_Win) the_real_win ));
    }
    virtual void Free( void ) 
    {
        MPIX_CALL( MPI_Win_free( (MPI_Win *) &the_real_win ));
    }
    virtual void Put( const void * v1, int v2, const Datatype &v3, int v4, Aint v5, int v6, const Datatype &v7 ) const
    {
        MPIX_CALL( MPI_Put( (void *)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, v6, (MPI_Datatype)(v7.the_real_datatype), (MPI_Win) the_real_win ));
    }
    virtual void Wait( void ) const
    {
        MPIX_CALL( MPI_Win_wait( (MPI_Win) the_real_win ));
    }
    virtual bool Test( void ) const
    {
        int v2;
        MPIX_CALL( MPI_Win_test( (MPI_Win) the_real_win, &v2 ));
        return v2!= 0;
    }
    virtual void Get( void * v1, int v2, const Datatype &v3, int v4, Aint v5, int v6, const Datatype &v7 ) const
    {
        MPIX_CALL( MPI_Get( v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, v6, (MPI_Datatype)(v7.the_real_datatype), (MPI_Win) the_real_win ));
    }
    virtual bool Get_attr( int v2, void * v3 ) const
    {
        int v4;
        MPIX_CALL( MPI_Win_get_attr( (MPI_Win) the_real_win, v2, v3, &v4 ));
        return v4!= 0;
    }
    virtual void Set_attr( int v2, const void * v3 ) 
    {
        MPIX_CALL( MPI_Win_set_attr( (MPI_Win) the_real_win, v2, (void *)v3 ));
    }
    virtual void Complete( void ) const
    {
        MPIX_CALL( MPI_Win_complete( (MPI_Win) the_real_win ));
    }
    virtual void Set_errhandler( const Errhandler &v2 ) 
    {
        MPIX_CALL( MPI_Win_set_errhandler( (MPI_Win) the_real_win, (MPI_Errhandler)(v2.the_real_errhandler) ));
    }
    virtual void Set_name( const char * v2 ) 
    {
        MPIX_CALL( MPI_Win_set_name( (MPI_Win) the_real_win, (char *)v2 ));
    }
    virtual void Accumulate( const void * v1, int v2, const Datatype &v3, int v4, Aint v5, int v6, const Datatype &v7, const Op &v8 ) const
    {
        MPIX_CALL( MPI_Accumulate( (void *)v1, v2, (MPI_Datatype)(v3.the_real_datatype), v4, v5, v6, (MPI_Datatype)(v7.the_real_datatype), (MPI_Op)(v8.the_real_op), (MPI_Win) the_real_win ));
    }
    static Win Create( const void * v1, Aint v2, int v3, const Info &v4, const Intracomm &v5 ) 
    {
        Win v6;
        MPIX_CALL( MPI_Win_create( (void *)v1, v2, v3, (MPI_Info)(v4.the_real_info), (MPI_Comm)(v5.the_real_comm), &(v6.the_real_win) ));
        return v6;
    }
    virtual void Call_errhandler( int v2 ) const;
    static void Free_keyval( int &v1 ) 
    {
        MPIX_CALL( MPI_Win_free_keyval( &v1 ));
    }
    virtual void Post( const Group &v1, int v2 ) const
    {
        MPIX_CALL( MPI_Win_post( (MPI_Group)(v1.the_real_group), v2, (MPI_Win) the_real_win ));
    }
    virtual void Unlock( int v1 ) const
    {
        MPIX_CALL( MPI_Win_unlock( v1, (MPI_Win) the_real_win ));
    }
    virtual void Delete_attr( int v2 ) 
    {
        MPIX_CALL( MPI_Win_delete_attr( (MPI_Win) the_real_win, v2 ));
    }
    virtual void Lock( int v1, int v2, int v3 ) const
    {
        MPIX_CALL( MPI_Win_lock( v1, v2, v3, (MPI_Win) the_real_win ));
    }
    virtual Errhandler Get_errhandler( void ) const
    {
        Errhandler v2;
        MPIX_CALL( MPI_Win_get_errhandler( (MPI_Win) the_real_win, &(v2.the_real_errhandler) ));
        return v2;
    }
    virtual void Get_name( char * v2, int &v3 ) const
    {
        MPIX_CALL( MPI_Win_get_name( (MPI_Win) the_real_win, v2, &v3 ));
    }
    typedef void Errhandler_function(Win &, int *, ... );
    typedef Errhandler_function Errhandler_fn;

    static Errhandler Create_errhandler( Errhandler_function * );

    typedef int Copy_attr_function(const Win& oldwin, int win_keyval, void* extra_state, void* attribute_val_in, void* attribute_val_out, bool& flag); 
    typedef int Delete_attr_function(Win& win, int win_keyval, void* attribute_val, void* extra_state); 

    static int Create_keyval( Copy_attr_function *, Delete_attr_function *,
                              void * );
    // These functions are *not* part of MPI-2 but are provided
    // because they should have been included
    static int NULL_COPY_FN( const Win &oldwin, int keyval, void *ex,
    void *attr_in, void *attr_out, bool &flag ) { flag = 1; return 0;}
    static int NULL_DELETE_FN( Win &win, int keyval, void * attr, 
         void *ex ) { return 0; }
    static int DUP_FN( const Win &oldwin, int keyval, void *ex,
    void *attr_in, void *attr_out, bool &flag ) { flag = 1; 
    *(void **)attr_out = attr_in; return 0;} 


};
#ifndef MPI_FILE_NULL
#define MPI_FILE_NULL 0
typedef int MPI_File;
#endif

class File  {

  protected:
    MPI_File the_real_file;

  public:
    // new/delete

    inline File(MPI_File obj) : the_real_file(obj) {}
    inline File(void) : the_real_file(MPI_FILE_NULL) {}

    virtual ~File() {}
    // copy/assignment

    File(const File &obj) : the_real_file(obj.the_real_file){}

    File& operator=(const File &obj) {
      the_real_file = obj.the_real_file; return *this; }

    // logical
    bool operator== (const File &obj) {
      return (the_real_file == obj.the_real_file); }
    bool operator!= (const File &obj) {
      return (the_real_file != obj.the_real_file); }
    // C/C++ cast and assignment
    inline operator MPI_File*() { return &the_real_file; }
    inline operator MPI_File() const { return the_real_file; }
    File& operator=(const MPI_File& obj) {
      the_real_file = obj; return *this; }
#ifdef MPI_MODE_RDONLY
    virtual Aint Get_type_extent( const Datatype &v2 ) const
    {
        MPI_Aint v3;
        MPIX_CALL( MPI_File_get_type_extent( (MPI_File) the_real_file, (MPI_Datatype)(v2.the_real_datatype), &v3 ));
        return v3;
    }
    virtual void Read_ordered_end( void * v2, Status & v3 ) 
    {
        MPIX_CALL( MPI_File_read_ordered_end( (MPI_File) the_real_file, v2, (MPI_Status *)&(v3.the_real_status ) ));
    }
    virtual void Read_ordered_end( void * v2 ) 
    {
        MPIX_CALL( MPI_File_read_ordered_end( (MPI_File) the_real_file, v2, MPI_STATUS_IGNORE ));
    }
    virtual void Seek_shared( Offset v2, int v3 ) 
    {
        MPIX_CALL( MPI_File_seek_shared( (MPI_File) the_real_file, v2, v3 ));
    }
    virtual void Read_ordered( void * v2, int v3, const Datatype &v4, Status & v5 ) 
    {
        MPIX_CALL( MPI_File_read_ordered( (MPI_File) the_real_file, v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPI_Status *)&(v5.the_real_status ) ));
    }
    virtual void Read_ordered( void * v2, int v3, const Datatype &v4 ) 
    {
        MPIX_CALL( MPI_File_read_ordered( (MPI_File) the_real_file, v2, v3, (MPI_Datatype)(v4.the_real_datatype), MPI_STATUS_IGNORE ));
    }
    virtual Request Iread_shared( void * v2, int v3, const Datatype &v4 ) 
    {
        Request v5;
        MPIX_CALL( MPI_File_iread_shared( (MPI_File) the_real_file, v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPIO_Request *)&(v5.the_real_request) ));
        return v5;
    }
    virtual Info Get_info( void ) const
    {
        Info v2;
        MPIX_CALL( MPI_File_get_info( (MPI_File) the_real_file, &(v2.the_real_info) ));
        return v2;
    }
    virtual void Write_ordered_begin( const void * v2, int v3, const Datatype &v4 ) 
    {
        MPIX_CALL( MPI_File_write_ordered_begin( (MPI_File) the_real_file, (void *)v2, v3, (MPI_Datatype)(v4.the_real_datatype) ));
    }
    virtual void Set_info( const Info &v2 ) 
    {
        MPIX_CALL( MPI_File_set_info( (MPI_File) the_real_file, (MPI_Info)(v2.the_real_info) ));
    }
    virtual void Write_ordered( const void * v2, int v3, const Datatype &v4, Status & v5 ) 
    {
        MPIX_CALL( MPI_File_write_ordered( (MPI_File) the_real_file, (void *)v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPI_Status *)&(v5.the_real_status ) ));
    }
    virtual void Write_ordered( const void * v2, int v3, const Datatype &v4 ) 
    {
        MPIX_CALL( MPI_File_write_ordered( (MPI_File) the_real_file, (void *)v2, v3, (MPI_Datatype)(v4.the_real_datatype), MPI_STATUS_IGNORE ));
    }
    virtual void Sync( void ) 
    {
        MPIX_CALL( MPI_File_sync( (MPI_File) the_real_file ));
    }
    virtual void Read( void * v2, int v3, const Datatype &v4, Status & v5 ) 
    {
        MPIX_CALL( MPI_File_read( (MPI_File) the_real_file, v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPI_Status *)&(v5.the_real_status ) ));
    }
    virtual void Read( void * v2, int v3, const Datatype &v4 ) 
    {
        MPIX_CALL( MPI_File_read( (MPI_File) the_real_file, v2, v3, (MPI_Datatype)(v4.the_real_datatype), MPI_STATUS_IGNORE ));
    }
    virtual void Write_all( const void * v2, int v3, const Datatype &v4, Status & v5 ) 
    {
        MPIX_CALL( MPI_File_write_all( (MPI_File) the_real_file, (void *)v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPI_Status *)&(v5.the_real_status ) ));
    }
    virtual void Write_all( const void * v2, int v3, const Datatype &v4 ) 
    {
        MPIX_CALL( MPI_File_write_all( (MPI_File) the_real_file, (void *)v2, v3, (MPI_Datatype)(v4.the_real_datatype), MPI_STATUS_IGNORE ));
    }
    virtual Offset Get_size( void ) const
    {
        MPI_Offset v2;
        MPIX_CALL( MPI_File_get_size( (MPI_File) the_real_file, &v2 ));
        return v2;
    }
    virtual void Write_all_end( const void * v2, Status & v3 ) 
    {
        MPIX_CALL( MPI_File_write_all_end( (MPI_File) the_real_file, (void *)v2, (MPI_Status *)&(v3.the_real_status ) ));
    }
    virtual void Write_all_end( const void * v2 ) 
    {
        MPIX_CALL( MPI_File_write_all_end( (MPI_File) the_real_file, (void *)v2, MPI_STATUS_IGNORE ));
    }
    static void Delete( const char * v1, const Info &v2 ) 
    {
        MPIX_CALL( MPI_File_delete( (char *)v1, (MPI_Info)(v2.the_real_info) ));
    }
    virtual void Read_ordered_begin( void * v2, int v3, const Datatype &v4 ) 
    {
        MPIX_CALL( MPI_File_read_ordered_begin( (MPI_File) the_real_file, v2, v3, (MPI_Datatype)(v4.the_real_datatype) ));
    }
    virtual Request Iread_at( Offset v2, void * v3, int v4, const Datatype &v5 ) 
    {
        Request v6;
        MPIX_CALL( MPI_File_iread_at( (MPI_File) the_real_file, v2, v3, v4, (MPI_Datatype)(v5.the_real_datatype), (MPIO_Request *)&(v6.the_real_request) ));
        return v6;
    }
    virtual void Write_at_all_end( const void * v2, Status & v3 ) 
    {
        MPIX_CALL( MPI_File_write_at_all_end( (MPI_File) the_real_file, (void *)v2, (MPI_Status *)&(v3.the_real_status ) ));
    }
    virtual void Write_at_all_end( const void * v2 ) 
    {
        MPIX_CALL( MPI_File_write_at_all_end( (MPI_File) the_real_file, (void *)v2, MPI_STATUS_IGNORE ));
    }
    virtual Offset Get_position_shared( void ) const
    {
        MPI_Offset v2;
        MPIX_CALL( MPI_File_get_position_shared( (MPI_File) the_real_file, &v2 ));
        return v2;
    }
    virtual void Write_shared( const void * v2, int v3, const Datatype &v4, Status & v5 ) 
    {
        MPIX_CALL( MPI_File_write_shared( (MPI_File) the_real_file, (void *)v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPI_Status *)&(v5.the_real_status ) ));
    }
    virtual void Write_shared( const void * v2, int v3, const Datatype &v4 ) 
    {
        MPIX_CALL( MPI_File_write_shared( (MPI_File) the_real_file, (void *)v2, v3, (MPI_Datatype)(v4.the_real_datatype), MPI_STATUS_IGNORE ));
    }
    virtual Request Iwrite_at( Offset v2, const void * v3, int v4, const Datatype &v5 ) 
    {
        Request v6;
        MPIX_CALL( MPI_File_iwrite_at( (MPI_File) the_real_file, (MPI_Offset)v2, (void *)v3, v4, (MPI_Datatype)(v5.the_real_datatype), (MPIO_Request *)&(v6.the_real_request) ));
        return v6;
    }
    virtual void Get_view( Offset & v2, Datatype &v3, Datatype &v4, char * v5 ) const
    {
        MPIX_CALL( MPI_File_get_view( (MPI_File) the_real_file, &v2, (MPI_Datatype *)&(v3.the_real_datatype), (MPI_Datatype *)&(v4.the_real_datatype), v5 ));
    }
    virtual void Call_errhandler( int v2 ) const;
    virtual void Write_all_begin( const void * v2, int v3, const Datatype &v4 ) 
    {
        MPIX_CALL( MPI_File_write_all_begin( (MPI_File) the_real_file, (void *)v2, v3, (MPI_Datatype)(v4.the_real_datatype) ));
    }
    virtual void Read_all_end( void * v2, Status & v3 ) 
    {
        MPIX_CALL( MPI_File_read_all_end( (MPI_File) the_real_file, v2, (MPI_Status *)&(v3.the_real_status ) ));
    }
    virtual void Read_all_end( void * v2 ) 
    {
        MPIX_CALL( MPI_File_read_all_end( (MPI_File) the_real_file, v2, MPI_STATUS_IGNORE ));
    }
    virtual Offset Get_byte_offset( const Offset v2 ) const
    {
        MPI_Offset v3;
        MPIX_CALL( MPI_File_get_byte_offset( (MPI_File) the_real_file, (MPI_Offset)v2, &v3 ));
        return v3;
    }
    virtual Request Iread( void * v2, int v3, const Datatype &v4 ) 
    {
        Request v5;
        MPIX_CALL( MPI_File_iread( (MPI_File) the_real_file, v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPIO_Request *)&(v5.the_real_request) ));
        return v5;
    }
    virtual void Read_at_all_end( void * v2, Status & v3 ) 
    {
        MPIX_CALL( MPI_File_read_at_all_end( (MPI_File) the_real_file, v2, (MPI_Status *)&(v3.the_real_status ) ));
    }
    virtual void Read_at_all_end( void * v2 ) 
    {
        MPIX_CALL( MPI_File_read_at_all_end( (MPI_File) the_real_file, v2, MPI_STATUS_IGNORE ));
    }
    virtual void Write_at( Offset v2, const void * v3, int v4, const Datatype &v5, Status & v6 ) 
    {
        MPIX_CALL( MPI_File_write_at( (MPI_File) the_real_file, v2, (void *)v3, v4, (MPI_Datatype)(v5.the_real_datatype), (MPI_Status *)&(v6.the_real_status ) ));
    }
    virtual void Write_at( Offset v2, const void * v3, int v4, const Datatype &v5 ) 
    {
        MPIX_CALL( MPI_File_write_at( (MPI_File) the_real_file, v2, (void *)v3, v4, (MPI_Datatype)(v5.the_real_datatype), MPI_STATUS_IGNORE ));
    }
    virtual void Write_at_all_begin( Offset v2, const void * v3, int v4, const Datatype &v5 ) 
    {
        MPIX_CALL( MPI_File_write_at_all_begin( (MPI_File) the_real_file, v2, (void *)v3, v4, (MPI_Datatype)(v5.the_real_datatype) ));
    }
    virtual Errhandler Get_errhandler( void ) const
    {
        Errhandler v2;
        MPIX_CALL( MPI_File_get_errhandler( (MPI_File) the_real_file, &(v2.the_real_errhandler) ));
        return v2;
    }
    virtual int Get_amode( void ) const
    {
        int v2;
        MPIX_CALL( MPI_File_get_amode( (MPI_File) the_real_file, &v2 ));
        return v2;
    }
    virtual void Set_atomicity( bool v2 ) 
    {
        int l2;
         l2 = (v2 == true) ? 1 : 0;
        MPIX_CALL( MPI_File_set_atomicity( (MPI_File) the_real_file, l2 ));
    }
    virtual Group Get_group( void ) const
    {
        Group v2;
        MPIX_CALL( MPI_File_get_group( (MPI_File) the_real_file, &(v2.the_real_group) ));
        return v2;
    }
    virtual Offset Get_position( void ) const
    {
        MPI_Offset v2;
        MPIX_CALL( MPI_File_get_position( (MPI_File) the_real_file, &v2 ));
        return v2;
    }
    static File Open( const Intracomm &v1, const char * v2, int v3, const Info &v4 ) 
    {
        File v5;
        MPIX_CALL( MPI_File_open( (MPI_Comm)(v1.the_real_comm), (char *)v2, v3, (MPI_Info)(v4.the_real_info), &(v5.the_real_file) ));
        return v5;
    }
    virtual void Seek( Offset v2, int v3 ) 
    {
        MPIX_CALL( MPI_File_seek( (MPI_File) the_real_file, v2, v3 ));
    }
    virtual void Read_all_begin( void * v2, int v3, const Datatype &v4 ) 
    {
        MPIX_CALL( MPI_File_read_all_begin( (MPI_File) the_real_file, v2, v3, (MPI_Datatype)(v4.the_real_datatype) ));
    }
    virtual void Read_at_all_begin( Offset v2, void * v3, int v4, const Datatype &v5 ) 
    {
        MPIX_CALL( MPI_File_read_at_all_begin( (MPI_File) the_real_file, v2, v3, v4, (MPI_Datatype)(v5.the_real_datatype) ));
    }
    virtual void Read_all( void * v2, int v3, const Datatype &v4, Status & v5 ) 
    {
        MPIX_CALL( MPI_File_read_all( (MPI_File) the_real_file, v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPI_Status *)&(v5.the_real_status ) ));
    }
    virtual void Read_all( void * v2, int v3, const Datatype &v4 ) 
    {
        MPIX_CALL( MPI_File_read_all( (MPI_File) the_real_file, v2, v3, (MPI_Datatype)(v4.the_real_datatype), MPI_STATUS_IGNORE ));
    }
    virtual void Preallocate( Offset v2 ) 
    {
        MPIX_CALL( MPI_File_preallocate( (MPI_File) the_real_file, v2 ));
    }
    virtual void Read_at_all( Offset v2, void * v3, int v4, const Datatype &v5, Status & v6 ) 
    {
        MPIX_CALL( MPI_File_read_at_all( (MPI_File) the_real_file, v2, v3, v4, (MPI_Datatype)(v5.the_real_datatype), (MPI_Status *)&(v6.the_real_status ) ));
    }
    virtual void Read_at_all( Offset v2, void * v3, int v4, const Datatype &v5 ) 
    {
        MPIX_CALL( MPI_File_read_at_all( (MPI_File) the_real_file, v2, v3, v4, (MPI_Datatype)(v5.the_real_datatype), MPI_STATUS_IGNORE ));
    }
    virtual void Read_shared( void * v2, int v3, const Datatype &v4, Status & v5 ) 
    {
        MPIX_CALL( MPI_File_read_shared( (MPI_File) the_real_file, v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPI_Status *)&(v5.the_real_status ) ));
    }
    virtual void Read_shared( void * v2, int v3, const Datatype &v4 ) 
    {
        MPIX_CALL( MPI_File_read_shared( (MPI_File) the_real_file, v2, v3, (MPI_Datatype)(v4.the_real_datatype), MPI_STATUS_IGNORE ));
    }
    virtual Request Iwrite( const void * v2, int v3, const Datatype &v4 ) 
    {
        Request v5;
        MPIX_CALL( MPI_File_iwrite( (MPI_File) the_real_file, (void *)v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPIO_Request *)&(v5.the_real_request) ));
        return v5;
    }
    virtual Request Iwrite_shared( const void * v2, int v3, const Datatype &v4 ) 
    {
        Request v5;
        MPIX_CALL( MPI_File_iwrite_shared( (MPI_File) the_real_file, (void *)v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPIO_Request *)&(v5.the_real_request) ));
        return v5;
    }
    virtual void Set_errhandler( const Errhandler &v2 ) 
    {
        MPIX_CALL( MPI_File_set_errhandler( (MPI_File) the_real_file, (MPI_Errhandler)(v2.the_real_errhandler) ));
    }
    virtual void Write_at_all( Offset v2, const void * v3, int v4, const Datatype &v5, Status & v6 ) 
    {
        MPIX_CALL( MPI_File_write_at_all( (MPI_File) the_real_file, v2, (void *)v3, v4, (MPI_Datatype)(v5.the_real_datatype), (MPI_Status *)&(v6.the_real_status ) ));
    }
    virtual void Write_at_all( Offset v2, const void * v3, int v4, const Datatype &v5 ) 
    {
        MPIX_CALL( MPI_File_write_at_all( (MPI_File) the_real_file, v2, (void *)v3, v4, (MPI_Datatype)(v5.the_real_datatype), MPI_STATUS_IGNORE ));
    }
    virtual void Set_size( Offset v2 ) 
    {
        MPIX_CALL( MPI_File_set_size( (MPI_File) the_real_file, v2 ));
    }
    virtual void Set_view( Offset v2, const Datatype &v3, const Datatype v4, const char * v5, const Info &v6 ) 
    {
        MPIX_CALL( MPI_File_set_view( (MPI_File) the_real_file, v2, (MPI_Datatype)(v3.the_real_datatype), (MPI_Datatype)v4, (char *)v5, (MPI_Info)(v6.the_real_info) ));
    }
    virtual void Read_at( Offset v2, void * v3, int v4, const Datatype &v5, Status & v6 ) 
    {
        MPIX_CALL( MPI_File_read_at( (MPI_File) the_real_file, v2, v3, v4, (MPI_Datatype)(v5.the_real_datatype), (MPI_Status *)&(v6.the_real_status ) ));
    }
    virtual void Read_at( Offset v2, void * v3, int v4, const Datatype &v5 ) 
    {
        MPIX_CALL( MPI_File_read_at( (MPI_File) the_real_file, v2, v3, v4, (MPI_Datatype)(v5.the_real_datatype), MPI_STATUS_IGNORE ));
    }
    virtual void Close( void ) 
    {
        MPIX_CALL( MPI_File_close( (MPI_File *) &the_real_file ));
    }
    virtual void Write_ordered_end( const void * v2, Status & v3 ) 
    {
        MPIX_CALL( MPI_File_write_ordered_end( (MPI_File) the_real_file, (void *)v2, (MPI_Status *)&(v3.the_real_status ) ));
    }
    virtual void Write_ordered_end( const void * v2 ) 
    {
        MPIX_CALL( MPI_File_write_ordered_end( (MPI_File) the_real_file, (void *)v2, MPI_STATUS_IGNORE ));
    }
    virtual void Write( const void * v2, int v3, const Datatype &v4, Status & v5 ) 
    {
        MPIX_CALL( MPI_File_write( (MPI_File) the_real_file, (void *)v2, v3, (MPI_Datatype)(v4.the_real_datatype), (MPI_Status *)&(v5.the_real_status ) ));
    }
    virtual void Write( const void * v2, int v3, const Datatype &v4 ) 
    {
        MPIX_CALL( MPI_File_write( (MPI_File) the_real_file, (void *)v2, v3, (MPI_Datatype)(v4.the_real_datatype), MPI_STATUS_IGNORE ));
    }
    virtual bool Get_atomicity( void ) const
    {
        int v2;
        MPIX_CALL( MPI_File_get_atomicity( (MPI_File) the_real_file, &v2 ));
        return v2!= 0;
    }
    typedef void Errhandler_function(File &, int *, ... );
    typedef Errhandler_function Errhandler_fn;

    static Errhandler Create_errhandler( Errhandler_function * );

#endif
};

class Graphcomm : public Intracomm {

  public:
    // new/delete

    inline Graphcomm(MPI_Comm obj) : Intracomm(obj) {}
    inline Graphcomm(void) : Intracomm() {}

    virtual ~Graphcomm() {}
    // copy/assignment

    Graphcomm(const Graphcomm &obj) : Intracomm(obj) {}

    Graphcomm& operator=(const Graphcomm &obj) {
      the_real_comm = obj.the_real_comm; return *this; }

    // C/C++ cast and assignment
    inline operator MPI_Comm*() { return &the_real_comm; }
    inline operator MPI_Comm() const { return the_real_comm; }
    Graphcomm& operator=(const MPI_Comm& obj) {
      the_real_comm = obj; return *this; }
    virtual void Get_dims( int * v2, int * v3 ) const
    {
        MPIX_CALL( MPI_Graphdims_get( (MPI_Comm) the_real_comm, v2, v3 ));
    }
    virtual void Get_topo( int v2, int v3, int * v4, int * v5 ) const
    {
        MPIX_CALL( MPI_Graph_get( (MPI_Comm) the_real_comm, v2, v3, v4, v5 ));
    }
    virtual int Map( int v2, const int * v3, const int * v4 ) const
    {
        int v5;
        MPIX_CALL( MPI_Graph_map( (MPI_Comm) the_real_comm, v2, (int *)v3, (int *)v4, &v5 ));
        return v5;
    }
    virtual void Get_neighbors( int v2, int v3, int * v4 ) const
    {
        MPIX_CALL( MPI_Graph_neighbors( (MPI_Comm) the_real_comm, v2, v3, v4 ));
    }
    virtual int Get_neighbors_count( int v2 ) const
    {
        int v3;
        MPIX_CALL( MPI_Graph_neighbors_count( (MPI_Comm) the_real_comm, v2, &v3 ));
        return v3;
    }
    Graphcomm Dup( void ) const
    {
        Graphcomm v2;
        MPIX_CALL( MPI_Comm_dup( (MPI_Comm) the_real_comm, &(v2.the_real_comm) ));
        return v2;
    }
    
// If the compiler does not support variable return types, return a 
// reference to Comm.  The user must then cast this to the correct type
// (Standard-conforming C++ compilers support variable return types)
#ifdef HAVE_NO_VARIABLE_RETURN_TYPE_SUPPORT
    virtual Comm & Clone(void) const { 
        MPI_Comm ncomm;
        MPI_Comm_dup( (MPI_Comm)the_real_comm, &ncomm); 
        Comm *clone = new Graphcomm(ncomm); 
        return *clone; 
    };
#else
    virtual Graphcomm & Clone(void) const { 
        MPI_Comm ncomm;
        MPI_Comm_dup( (MPI_Comm)the_real_comm, &ncomm); 
        Graphcomm *clone = new Graphcomm(ncomm); 
        return *clone; 
    };
#endif
};

class Cartcomm : public Intracomm {

  public:
    // new/delete

    inline Cartcomm(MPI_Comm obj) : Intracomm(obj) {}
    inline Cartcomm(void) : Intracomm() {}

    virtual ~Cartcomm() {}
    // copy/assignment

    Cartcomm(const Cartcomm &obj) : Intracomm(obj) {}

    Cartcomm& operator=(const Cartcomm &obj) {
      the_real_comm = obj.the_real_comm; return *this; }

    // C/C++ cast and assignment
    inline operator MPI_Comm*() { return &the_real_comm; }
    inline operator MPI_Comm() const { return the_real_comm; }
    Cartcomm& operator=(const MPI_Comm& obj) {
      the_real_comm = obj; return *this; }
    virtual void Get_coords( int v2, int v3, int * v4 ) const
    {
        MPIX_CALL( MPI_Cart_coords( (MPI_Comm) the_real_comm, v2, v3, v4 ));
    }
    virtual int Get_cart_rank( const int * v2 ) const
    {
        int v3;
        MPIX_CALL( MPI_Cart_rank( (MPI_Comm) the_real_comm, (int *)v2, &v3 ));
        return v3;
    }
    virtual int Get_dim( void ) const
    {
        int v2;
        MPIX_CALL( MPI_Cartdim_get( (MPI_Comm) the_real_comm, &v2 ));
        return v2;
    }
    virtual void Get_topo( int v2, int * v3, bool v4[], int * v5 ) const
    {
        int *l4 = new int[v2];
        MPIX_CALL( MPI_Cart_get( (MPI_Comm) the_real_comm, v2, v3, l4, v5 ));
        { 
            int i4; 
            for (i4=0;i4<v2;i4++) {
		// Unfortunately, at least one C++ compiler (Microsoft's)
		// generates warning messages when the type size changes
		// even when an explicit cast is used.  To avoid these messages, we 
		// cause the generated code to explicitly compute a
		// boolean value
                v4[i4] = l4[i4] != 0;
            }
            delete[] l4;
        }
    }
    virtual int Map( int v2, const int * v3, const bool v4[] ) const
    {
        int v5;
        int *l4 = new int[v2];
        { 
            int i4; 
            for (i4=0;i4<v2;i4++) {
                l4[i4] = v4[i4] == true ? 1 : 0;
            }
        }
        MPIX_CALL( MPI_Cart_map( (MPI_Comm) the_real_comm, v2, (int *)v3, l4, &v5 ));

            delete[] l4;
        return v5;
    }
    virtual Cartcomm Sub( const bool v2[] ) const
    {
        Cartcomm v3;
        int *l2 = new int[10];
        { 
            int i2; 
            for (i2=0;i2<10;i2++) {
                l2[i2] = v2[i2] == true ? 1 : 0;
            }
        }
        MPIX_CALL( MPI_Cart_sub( (MPI_Comm) the_real_comm, l2, &(v3.the_real_comm) ));

            delete[] l2;
        return v3;
    }
    virtual void Shift( int v2, int v3, int &v4, int &v5 ) const
    {
        MPIX_CALL( MPI_Cart_shift( (MPI_Comm) the_real_comm, v2, v3, &v4, &v5 ));
    }
    Cartcomm Dup( void ) const
    {
        Cartcomm v2;
        MPIX_CALL( MPI_Comm_dup( (MPI_Comm) the_real_comm, &(v2.the_real_comm) ));
        return v2;
    }
    
// If the compiler does not support variable return types, return a 
// reference to Comm.  The user must then cast this to the correct type
// (Standard-conforming C++ compilers support variable return types)
#ifdef HAVE_NO_VARIABLE_RETURN_TYPE_SUPPORT
    virtual Comm & Clone(void) const { 
        MPI_Comm ncomm;
        MPI_Comm_dup( (MPI_Comm)the_real_comm, &ncomm); 
        Comm *clone = new Cartcomm(ncomm); 
        return *clone; 
    };
#else
    virtual Cartcomm & Clone(void) const { 
        MPI_Comm ncomm;
        MPI_Comm_dup( (MPI_Comm)the_real_comm, &ncomm); 
        Cartcomm *clone = new Cartcomm(ncomm); 
        return *clone; 
    };
#endif
};
extern     int Add_error_class( void ) ;
extern     void* Alloc_mem( Aint v1, const Info &v2 ) ;
extern     void Lookup_name( const char * v1, const Info &v2, char * v3 ) ;
extern     void Publish_name( const char * v1, const Info &v2, const char * v3 ) ;
extern     void Unpublish_name( const char * v1, const Info &v2, const char * v3 ) ;
extern     Aint Get_address( void * v1 ) ;
extern     void Add_error_string( int v1, const char * v2 ) ;
extern     int Query_thread( void ) ;
extern     void Close_port( const char * v1 ) ;
extern     int Add_error_code( int v1 ) ;
extern     void Free_mem( void * v1 ) ;
extern     void Open_port( const Info &v1, char * v2 ) ;
extern     bool Is_finalized( void ) ;
extern     bool Is_thread_main( void ) ;

#ifdef MPI_MODE_RDONLY
typedef int Datarep_extent_function( const Datatype&, Aint&, void *);
typedef int Datarep_conversion_function( void *, Datatype &, int, void *,
                Offset, void * );
#endif


extern Datatype CHAR;
extern Datatype UNSIGNED_CHAR;
extern Datatype BYTE;
extern Datatype SHORT;
extern Datatype UNSIGNED_SHORT;
extern Datatype INT;
extern Datatype UNSIGNED;
extern Datatype LONG;
extern Datatype UNSIGNED_LONG;
extern Datatype FLOAT;
extern Datatype DOUBLE;
extern Datatype LONG_DOUBLE;
extern Datatype LONG_LONG_INT;
extern Datatype LONG_LONG;
extern Datatype PACKED;
extern Datatype LB;
extern Datatype UB;
extern Datatype FLOAT_INT;
extern Datatype DOUBLE_INT;
extern Datatype LONG_INT;
extern Datatype SHORT_INT;
extern Datatype LONG_DOUBLE_INT;
extern Datatype REAL4;
extern Datatype REAL8;
extern Datatype REAL16;
extern Datatype COMPLEX8;
extern Datatype COMPLEX16;
extern Datatype COMPLEX32;
extern Datatype INTEGER1;
extern Datatype INTEGER2;
extern Datatype INTEGER4;
extern Datatype INTEGER8;
extern Datatype INTEGER16;
extern Datatype WCHAR;
extern Datatype SIGNED_CHAR;
extern Datatype UNSIGNED_LONG_LONG;
extern Datatype TWOINT;
extern Datatype BOOL;
#define MPIR_CXX_BOOL 0x4c000133
extern Datatype COMPLEX;
#define MPIR_CXX_COMPLEX 0x4c000834
extern Datatype DOUBLE_COMPLEX;
#define MPIR_CXX_DOUBLE_COMPLEX 0x4c001035
extern Datatype LONG_DOUBLE_COMPLEX;
#define MPIR_CXX_LONG_DOUBLE_COMPLEX 0x4c002036
extern Datatype DATATYPE_NULL;

#if 1
extern Datatype INTEGER;
extern Datatype REAL;
extern Datatype DOUBLE_PRECISION;
extern Datatype F_COMPLEX;
extern Datatype F_DOUBLE_COMPLEX;
extern Datatype LOGICAL;
extern Datatype CHARACTER;
extern Datatype TWOREAL;
extern Datatype TWODOUBLE_PRECISION;
extern Datatype TWOINTEGER;
#endif
extern const Op MAX;
extern const Op MIN;
extern const Op SUM;
extern const Op PROD;
extern const Op LAND;
extern const Op BAND;
extern const Op LOR;
extern const Op BOR;
extern const Op LXOR;
extern const Op BXOR;
extern const Op MINLOC;
extern const Op MAXLOC;
extern const Op REPLACE;
extern const Op OP_NULL;
extern Intracomm COMM_WORLD;
extern Intracomm COMM_SELF;
extern const Group GROUP_EMPTY;
extern const Nullcomm COMM_NULL;
extern const Group GROUP_NULL;
extern const Request REQUEST_NULL;
extern const Errhandler ERRHANDLER_NULL;
extern const Errhandler ERRORS_RETURN;
extern const Errhandler ERRORS_ARE_FATAL;
extern const Errhandler ERRORS_THROW_EXCEPTIONS;
extern const Info INFO_NULL;
extern const Win WIN_NULL;
extern  File FILE_NULL;
extern const int BSEND_OVERHEAD;
extern const int KEYVAL_INVALID;
extern const int CART;
extern const int GRAPH;
extern const int IDENT;
extern const int SIMILAR;
extern const int CONGRUENT;
extern const int UNEQUAL;
extern const int PROC_NULL;
extern const int ANY_TAG;
extern const int ANY_SOURCE;
extern const int ROOT;
extern const int TAG_UB;
extern const int IO;
extern const int HOST;
extern const int WTIME_IS_GLOBAL;
extern const int UNIVERSE_SIZE;
extern const int LASTUSEDCODE;
extern const int APPNUM;
extern const int MAX_PROCESSOR_NAME;
extern const int MAX_ERROR_STRING;
extern const int MAX_PORT_NAME;
extern const int MAX_OBJECT_NAME;
extern const int MAX_INFO_VAL;
extern const int MAX_INFO_KEY;
extern const int UNDEFINED;
extern const int LOCK_EXCLUSIVE;
extern const int LOCK_SHARED;
extern const int WIN_BASE;
extern const int WIN_DISP_UNIT;
extern const int WIN_SIZE;
extern const int SUCCESS;
extern const int ERR_BUFFER;
extern const int ERR_COUNT;
extern const int ERR_TYPE;
extern const int ERR_TAG;
extern const int ERR_COMM;
extern const int ERR_RANK;
extern const int ERR_REQUEST;
extern const int ERR_ROOT;
extern const int ERR_GROUP;
extern const int ERR_OP;
extern const int ERR_TOPOLOGY;
extern const int ERR_DIMS;
extern const int ERR_ARG;
extern const int ERR_UNKNOWN;
extern const int ERR_TRUNCATE;
extern const int ERR_OTHER;
extern const int ERR_INTERN;
extern const int ERR_PENDING;
extern const int ERR_IN_STATUS;
extern const int ERR_LASTCODE;
extern const int ERR_FILE;
extern const int ERR_ACCESS;
extern const int ERR_AMODE;
extern const int ERR_BAD_FILE;
extern const int ERR_FILE_EXISTS;
extern const int ERR_FILE_IN_USE;
extern const int ERR_NO_SPACE;
extern const int ERR_NO_SUCH_FILE;
extern const int ERR_IO;
extern const int ERR_READ_ONLY;
extern const int ERR_CONVERSION;
extern const int ERR_DUP_DATAREP;
extern const int ERR_UNSUPPORTED_DATAREP;
extern const int ERR_INFO;
extern const int ERR_INFO_KEY;
extern const int ERR_INFO_VALUE;
extern const int ERR_INFO_NOKEY;
extern const int ERR_NAME;
extern const int ERR_NO_MEM;
extern const int ERR_NOT_SAME;
extern const int ERR_PORT;
extern const int ERR_QUOTA;
extern const int ERR_SERVICE;
extern const int ERR_SPAWN;
extern const int ERR_UNSUPPORTED_OPERATION;
extern const int ERR_WIN;
extern const int ERR_BASE;
extern const int ERR_LOCKTYPE;
extern const int ERR_KEYVAL;
extern const int ERR_RMA_CONFLICT;
extern const int ERR_RMA_SYNC;
extern const int ERR_SIZE;
extern const int ERR_DISP;
extern const int ERR_ASSERT;
extern const int TYPECLASS_REAL;
extern const int TYPECLASS_INTEGER;
extern const int TYPECLASS_COMPLEX;
#if defined(MPI_SEEK_SET) && !defined(MPICH_IGNORE_CXX_SEEK) && !defined(SEEK_SET)
extern const int SEEK_SET;
extern const int SEEK_END;
extern const int SEEK_CUR;
#endif
extern const int DISTRIBUTE_BLOCK;
extern const int DISTRIBUTE_CYCLIC;
extern const int DISTRIBUTE_DFLT_DARG;
extern const int DISTRIBUTE_NONE;
extern const int ORDER_C;
extern const int ORDER_FORTRAN;
// Include these only if MPI-IO is available
#ifdef MPI_MODE_RDONLY
extern const int MAX_DATAREP_STRING;
extern const MPI_Offset DISPLACEMENT_CURRENT;
extern const int MODE_APPEND;
extern const int MODE_CREATE;
extern const int MODE_DELETE_ON_CLOSE;
extern const int MODE_EXCL;
extern const int MODE_RDONLY;
extern const int MODE_RDWR;
extern const int MODE_SEQUENTIAL;
extern const int MODE_UNIQUE_OPEN;
extern const int MODE_WRONLY;
#endif // IO
extern const int MODE_NOCHECK;
extern const int MODE_NOPRECEDE;
extern const int MODE_NOPUT;
extern const int MODE_NOSTORE;
extern const int MODE_NOSUCCEED;
extern const int COMBINER_CONTIGUOUS;
extern const int COMBINER_DARRAY;
extern const int COMBINER_DUP;
extern const int COMBINER_F90_COMPLEX;
extern const int COMBINER_F90_INTEGER;
extern const int COMBINER_F90_REAL;
extern const int COMBINER_HINDEXED_INTEGER;
extern const int COMBINER_HINDEXED;
extern const int COMBINER_HVECTOR_INTEGER;
extern const int COMBINER_HVECTOR;
extern const int COMBINER_INDEXED_BLOCK;
extern const int COMBINER_INDEXED;
extern const int COMBINER_NAMED;
extern const int COMBINER_RESIZED;
extern const int COMBINER_STRUCT_INTEGER;
extern const int COMBINER_STRUCT;
extern const int COMBINER_SUBARRAY;
extern const int COMBINER_VECTOR;
extern const int THREAD_FUNNELED;
extern const int THREAD_MULTIPLE;
extern const int THREAD_SERIALIZED;
extern const int THREAD_SINGLE;
extern const char ** const ARGV_NULL;
extern const char *** const ARGVS_NULL;
extern void * const BOTTOM;
extern void * const IN_PLACE;
extern void Init(void);
extern void Init(int &, char **& );
extern int Init_thread(int);
extern int Init_thread(int &, char **&, int );
extern double Wtime(void);
extern double Wtick(void);
} // namespace MPI
