/* -*- 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 -initfile=./cxx.vlist

 * 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__ >= @GNUCXX_VERSION@ 

#  if __GNUC_MINOR__ > 2 && @GNUCXX_MINORVERSION@ == 2 

#  error 'Please use the same version of GCC and g++ for compiling MPICH and user MPI programs'

#  endif

# endif     

#endif

/* 

 * Because the API is defined, some methods have parameters that are 

 * not used.  The following definition allows us to suppress warnings

 * about unused arguments in methods when -Wall -Wextra are specified.

 * this definition is removed at the end of this file.

 */

#ifdef MPIR_ARGUNUSED

#error MPIR_ARGUNUSED defined

#endif

#if defined(__GNUC__) && __GNUC__ >= 4 

#define MPIR_ARGUNUSED __attribute__((unused))

#else

#define MPIR_ARGUNUSED

#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 @HAVE_CXX_EXCEPTIONS@

#define MPIX_CALLREF( _objptr, fnc ) \

    { int err = fnc; if (err) { (_objptr)->Call_errhandler( err ); }}

#define MPIX_CALLOBJ( _obj, fnc ) \

    { int err = fnc; if (err) { (_obj).Call_errhandler( err ); }}

#define MPIX_CALLWORLD( fnc ) \

    { int err = fnc ; if (err) MPIR_Call_world_errhand( err ); }

extern void MPIR_Call_world_errhand( int );

#else

#define MPIX_CALLREF( _objptr, fnc ) (void)fnc

#define MPIX_CALLOBJ( _obj, fnc ) (void)fnc

#define MPIX_CALLWORLD( 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;

class File;

// 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 ) ;

extern     Intracomm COMM_WORLD;

extern     File FILE_NULL;

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_CALLWORLD( MPI_Type_commit( (MPI_Datatype *) &the_real_datatype ));

    }

    virtual void Free( void ) 

    {

        MPIX_CALLWORLD( MPI_Type_free( (MPI_Datatype *) &the_real_datatype ));

    }

    virtual Datatype Create_indexed( int v1, const int * v2, const int * v3 ) const

    {

        Datatype v5;

        MPIX_CALLWORLD( MPI_Type_indexed( v1, (const int *)v2, (const int *)v3, (MPI_Datatype) the_real_datatype, &(v5.the_real_datatype) ));

        return v5;

    }

    virtual Datatype Create_contiguous( int v1 ) const

    {

        Datatype v3;

        MPIX_CALLWORLD( 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_CALLWORLD( 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[], Aint v3[],  const Datatype v4[] ) 

    {

        Datatype v5;

        MPI_Datatype *l4 = new MPI_Datatype[v1];

        { 

            int i4; 

            for (i4=0;i4

                l4[i4] = v4[i4].the_real_datatype;

            }

        }

        MPIX_CALLWORLD( MPI_Type_create_struct( v1, (const int  *)v2, (const 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_CALLWORLD( 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_CALLWORLD( 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_CALLWORLD( 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_CALLWORLD( 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_CALLWORLD( 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_CALLWORLD( MPI_Type_create_indexed_block( v1, v2, (const int  *)v3, (MPI_Datatype) the_real_datatype, &(v5.the_real_datatype) ));

        return v5;

    }

    virtual Aint Pack_external_size( const char v1[], int v2 ) const

    {

        MPI_Aint v4;

        MPIX_CALLWORLD( MPI_Pack_external_size( v1, v2, (MPI_Datatype) the_real_datatype, &v4 ));

        return v4;

    }

    Datatype Dup( void ) const

    {

        Datatype v2;

        MPIX_CALLWORLD( 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_CALLWORLD( MPI_Type_create_hindexed( v1, (const int  *)v2, (const 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_CALLWORLD( 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_CALLWORLD( 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_CALLWORLD( MPI_Type_create_darray( v1, v2, v3, (const int  *)v4, (const int  *)v5, (const int  *)v6, (const 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_CALLWORLD( 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[], Aint v6[], Datatype v7[] ) const

    {

        MPI_Datatype *l7 = new MPI_Datatype[v4];

        MPIX_CALLWORLD( MPI_Type_get_contents( (MPI_Datatype) the_real_datatype, v2, v3, v4, v5, v6, l7 ));

        { 

            int i7; 

            for (i7=0;i7

                v7[i7].the_real_datatype = l7[i7];

            }

            delete[] l7;

        }

    }

    virtual void Set_attr( int v2, const void * v3 ) 

    {

        MPIX_CALLWORLD( MPI_Type_set_attr( (MPI_Datatype) the_real_datatype, v2, (void *)v3 ));

    }

    virtual void Set_name( const char * v2 ) 

    {

        MPIX_CALLWORLD( MPI_Type_set_name( (MPI_Datatype) the_real_datatype, (const char *)v2 ));

    }

    static Datatype Create_f90_complex( int v1, int v2 ) 

    {

        Datatype v3;

        MPIX_CALLWORLD( MPI_Type_create_f90_complex( v1, v2, &(v3.the_real_datatype) ));

        return v3;

    }

    virtual Datatype Create_subarray( int v1, const int v2[], const int v3[], const int v4[], const int v5 ) const

    {

        Datatype v7;

        MPIX_CALLWORLD( MPI_Type_create_subarray( v1, v2, (const int  *)v3, (const int  *)v4, (int)v5, (MPI_Datatype) the_real_datatype, &(v7.the_real_datatype) ));

        return v7;

    }

    virtual void Unpack_external( const char v1[], const void * v2, const Aint v3, Aint & v4, void * v5, int v6 ) const

    {

        MPIX_CALLWORLD( MPI_Unpack_external( v1, (const void *)v2, (MPI_Aint)v3, &v4, v5, v6, (MPI_Datatype) the_real_datatype ));

    }

    static void Free_keyval( int &v1 ) 

    {

        MPIX_CALLWORLD( 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

                l4[i4] = v4[i4].the_real_datatype;

            }

        }

        MPIX_CALLWORLD( MPI_Type_create_struct( v1, (const int  *)v2, (const MPI_Aint  *)v3, l4, &(v5.the_real_datatype) ));

                    delete[] l4;

        return v5;

    }

    static Datatype Create_f90_integer( int v1 ) 

    {

        Datatype v2;

        MPIX_CALLWORLD( MPI_Type_create_f90_integer( v1, &(v2.the_real_datatype) ));

        return v2;

    }

    virtual void Pack_external( const char v1[], const void * v2, const int v3, void * v5, Aint v6, Aint & v7 ) const

    {

        MPIX_CALLWORLD( MPI_Pack_external( v1, (const void *)v2, (int)v3, (MPI_Datatype) the_real_datatype, v5, v6, &v7 ));

    }

    virtual void Get_extent( Aint & v2, Aint & v3 ) const

    {

        MPIX_CALLWORLD( MPI_Type_get_extent( (MPI_Datatype) the_real_datatype, &v2, &v3 ));

    }

    virtual void Delete_attr( int v2 ) 

    {

        MPIX_CALLWORLD( MPI_Type_delete_attr( (MPI_Datatype) the_real_datatype, v2 ));

    }

    virtual void Get_name( char * v2, int &v3 ) const

    {

    MPIR_CXX_InitDatatypeNames();

        MPIX_CALLWORLD( 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 MPIR_ARGUNUSED, 

        int keyval MPIR_ARGUNUSED, void *ex MPIR_ARGUNUSED,

        void *attr_in MPIR_ARGUNUSED, void *attr_out MPIR_ARGUNUSED, 

        bool &flag ) { flag = 1; return 0;}

    static int NULL_DELETE_FN( Datatype &type MPIR_ARGUNUSED, 

        int keyval MPIR_ARGUNUSED, void * attr MPIR_ARGUNUSED, 

        void *ex MPIR_ARGUNUSED ) { return 0; }

    static int DUP_FN( const Datatype &oldtype MPIR_ARGUNUSED, 

        int keyval MPIR_ARGUNUSED, void *ex MPIR_ARGUNUSED,

        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_CALLWORLD( MPI_Info_delete( (MPI_Info) the_real_info, (const char *)v2 ));

    }

    virtual void Get_nthkey( int v2, char * v3 ) const

    {

        MPIX_CALLWORLD( MPI_Info_get_nthkey( (MPI_Info) the_real_info, v2, v3 ));

    }

    virtual void Free( void ) 

    {

        MPIX_CALLWORLD( MPI_Info_free( (MPI_Info *) &the_real_info ));

    }

    static Info Create( void ) 

    {

        Info v1;

        MPIX_CALLWORLD( MPI_Info_create( &(v1.the_real_info) ));

        return v1;

    }

    virtual void Set( const char * v2, const char * v3 ) 

    {

        MPIX_CALLWORLD( MPI_Info_set( (MPI_Info) the_real_info, (const char *)v2, (const char *)v3 ));

    }

    Info Dup( void ) const

    {

        Info v2;

        MPIX_CALLWORLD( 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_CALLWORLD( MPI_Info_get_valuelen( (MPI_Info) the_real_info, (const char *)v2, &v3, &v4 ));

        return v4!= 0;

    }

    virtual bool Get( const char * v2, int v3, char * v4 ) const

    {

        int v5;

        MPIX_CALLWORLD( MPI_Info_get( (MPI_Info) the_real_info, (const char *)v2, v3, v4, &v5 ));

        return v5!= 0;

    }

    virtual int Get_nkeys( void ) const

    {

        int v2;

        MPIX_CALLWORLD( 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_CALLWORLD( MPI_Test_cancelled( (const MPI_Status *) &the_real_status, &v2 ));

        return v2!= 0;

    }

    virtual int Get_elements( const Datatype &v2 ) const

    {

        int v3;

        MPIX_CALLWORLD( MPI_Get_elements( (const 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_CALLWORLD( MPI_Get_count( (const 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_CALLWORLD( MPI_Status_set_cancelled( (MPI_Status *) &the_real_status, l2 ));

    }

    virtual void Set_elements( const Datatype &v2, int v3 ) 

    {

        MPIX_CALLWORLD( 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_CALLWORLD( MPI_Group_excl( (MPI_Group) the_real_group, v2, (const int  *)v3, &(v4.the_real_group) ));

        return v4;

    }

    virtual int Get_rank( void ) const

    {

        int v2;

        MPIX_CALLWORLD( MPI_Group_rank( (MPI_Group) the_real_group, &v2 ));

        return v2;

    }

    virtual void Free( void ) 

    {

        MPIX_CALLWORLD( MPI_Group_free( (MPI_Group *) &the_real_group ));

    }

    static Group Union( const Group &v1, const Group &v2 ) 

    {

        Group v3;

        MPIX_CALLWORLD( 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_CALLWORLD( 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_CALLWORLD( 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_CALLWORLD( 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_CALLWORLD( 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_CALLWORLD( MPI_Group_translate_ranks( (MPI_Group)(v1.the_real_group), v2, (const int  *)v3, (MPI_Group)(v4.the_real_group), v5 ));

    }

    virtual Group Incl( int v2, const int v3[] ) const

    {

        Group v4;

        MPIX_CALLWORLD( MPI_Group_incl( (MPI_Group) the_real_group, v2, (const int  *)v3, &(v4.the_real_group) ));

        return v4;

    }

    virtual int Get_size( void ) const

    {

        int v2;

        MPIX_CALLWORLD( MPI_Group_size( (MPI_Group) the_real_group, &v2 ));

        return v2;

    }

    static int Compare( const Group &v1, const Group &v2 ) 

    {

        int v3;

        MPIX_CALLWORLD( 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_CALLWORLD( MPI_Op_free( (MPI_Op *) &the_real_op ));

    }

    virtual bool Is_commutative( void ) const

    {

        int v2;

        MPIX_CALLWORLD( MPI_Op_commutative( (MPI_Op) the_real_op, &v2 ));

        return v2!= 0;

    }

    virtual void Reduce_local( const void * v1, void * v2, int v3, const Datatype &v4 ) const

    {

        MPIX_CALLWORLD( MPI_Reduce_local( (const void *)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_CALLWORLD( 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

                l2[i2] = v2[i2].the_real_request;

            }

        }

        MPIX_CALLWORLD( MPI_Testany( v1, l2, &v3, &v4, (MPI_Status *)&(v5.the_real_status ) ));

        { 

            int i2; 

            for (i2=0;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

                l2[i2] = v2[i2].the_real_request;

            }

        }

        MPIX_CALLWORLD( MPI_Testany( v1, l2, &v3, &v4, MPI_STATUS_IGNORE ));

        { 

            int i2; 

            for (i2=0;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

                l2[i2] = v2[i2].the_real_request;

            }

        }

        MPIX_CALLWORLD( MPI_Waitsome( v1, l2, &v3, v4, l5 ));

        { 

            int i2; 

            for (i2=0;i2

                v2[i2].the_real_request = l2[i2];

            }

            delete[] l2;

        }

        { 

            int i5; 

            for (i5=0;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

                l2[i2] = v2[i2].the_real_request;

            }

        }

        MPIX_CALLWORLD( MPI_Waitsome( v1, l2, &v3, v4, MPI_STATUSES_IGNORE ));

        { 

            int i2; 

            for (i2=0;i2

                v2[i2].the_real_request = l2[i2];

            }

            delete[] l2;