MpiSendRecv.cpp

#ifdef  UTIL_MPI

#include <string.h>
/*
* Util Package - C++ Utilities for Scientific Computation
*
* Copyright 2010 - 2017, The Regents of the University of Minnesota
* Distributed under the terms of the GNU General Public License.
*/

#include "MpiSendRecv.h"

namespace Util
{

   // bool explicit specializations
 
   template <>
   void send<bool>(MPI::Comm& comm, bool& data, int dest, int tag)
   { 
      int value = data ? 1 : 0;
      send<int>(comm, value, dest, tag);
   }

   template <>
   void recv<bool>(MPI::Comm& comm, bool& data, int source, int tag)
   { 
      int value;
      recv<int>(comm, value, source, tag);
      data = value ? true : false;
   }

   template <>
   void bcast<bool>(MPI::Intracomm& comm, bool& data, int root)
   { 
      int value;
      int rank = comm.Get_rank();
      if (rank == root) 
         value = data ? 1 : 0;
      bcast<int>(comm, value, root);
      if (rank != root) 
         data = value ? true : false;
   }

   // std::string explicit specializations
 
   template <>
   void send<std::string>(MPI::Comm& comm, std::string& data, int dest, int tag)
   { 

      // Send size of char C array
      int count = data.size() + 1;
      send<int>(comm, count, dest, tag);

      // Send string contents as char array
      char* cstr = new char[count];
      strcpy(cstr, data.c_str());
      send<char>(comm, cstr, count, dest, tag); 
      delete [] cstr;

   }

   template <>
   void recv<std::string>(MPI::Comm& comm, std::string& data, int source, int tag)
   { 

      // Receive size of char C array
      int  count;
      recv<int>(comm, count, source, tag);

      // Receive contents as char C array
      char* cstr = new char[count];
      recv<char>(comm, cstr, count, source, tag); 
      data = cstr;
      delete [] cstr;

   }

   template <>
   void bcast<std::string>(MPI::Intracomm& comm, std::string& data, int root)
   { 
      int rank = comm.Get_rank();
      int count;

      // Broadcast string count
      if (rank == root) 
         count = data.size() + 1;
      bcast<int>(comm, count, root);

      // Broadcast std::string contents as C string
      char* cstr = new char[count];
      if (rank == root) 
         strcpy(cstr, data.c_str());
      bcast<char>(comm, cstr, count, root); 
      if (rank != root) 
         data = cstr;
      delete [] cstr;

   }

}
#endif