src/Communication/ReceiverFactory.cxx

   1 // Copyright (C) 2005  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   2 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   3 //
   4 // This library is free software; you can redistribute it and/or
   5 // modify it under the terms of the GNU Lesser General Public
   6 // License as published by the Free Software Foundation; either
   7 // version 2.1 of the License.
   8 //
   9 // This library is distributed in the hope that it will be useful
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 // Lesser General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Lesser General Public
  15 // License along with this library; if not, write to the Free Software
  16 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17 //
  18 // See http://www.salome-platform.org/
  19 //
  20 #ifdef HAVE_MPI2
  21 #include "mpi.h"
  22 #endif
  23 #include "ReceiverFactory.hxx"
  24 #include "Receivers.hxx"
  25 using namespace std;
  26
  27 #ifdef COMP_CORBA_DOUBLE
  28 #define CorbaDNoCopyReceiver CorbaNCNoCopyReceiver
  29 #define CorbaDWithCopyReceiver CorbaNCWithCopyReceiver
  30 #else
  31 #define CorbaDNoCopyReceiver CorbaWCNoCopyReceiver
  32 #define CorbaDWithCopyReceiver CorbaWCWithCopyReceiver
  33 #endif
  34
  35 #ifdef COMP_CORBA_LONG
  36 #define CorbaINoCopyReceiver CorbaNCNoCopyReceiver
  37 #define CorbaIWithCopyReceiver CorbaNCWithCopyReceiver
  38 #else
  39 #define CorbaINoCopyReceiver CorbaWCNoCopyReceiver
  40 #define CorbaIWithCopyReceiver CorbaWCWithCopyReceiver
  41 #endif
  42
  43 #ifdef HAVE_SOCKET
  44 #include <rpc/xdr.h>
  45 #endif
  46
  47 /*!
  48   This method performs the transfert of double array with the remote SenderDouble given. If it fails with this SenderDouble it tries with an another protocol (CORBA by default).
  49  */
  50 double *ReceiverFactory::getValue(SALOME::SenderDouble_ptr sender,long &size)throw(MultiCommException)
  51 {
  52   double *ret;
  53   try{
  54     ret=getValueOneShot(sender,size);
  55   }
  56   catch(MultiCommException&)
  57     {
  58       SALOME::SenderDouble_ptr newSender=sender->buildOtherWithProtocol(SALOME::CORBA_);
  59       MESSAGE("PROTOCOL CHANGED TO CORBA");
  60       sender->release();
  61       ret=getValueOneShot(newSender,size);
  62       CORBA::release(newSender);
  63     }
  64   return ret;
  65 }
  66
  67 /*!
  68   This method performs the transfert of int array with the remote SenderInt given. If it fails with this SenderInt it tries with an another protocol (CORBA by default).
  69  */
  70 int *ReceiverFactory::getValue(SALOME::SenderInt_ptr sender,long &size)throw(MultiCommException)
  71 {
  72   int *ret;
  73   try{
  74     ret=getValueOneShot(sender,size);
  75   }
  76   catch(MultiCommException&)
  77     {
  78       SALOME::SenderInt_ptr newSender=sender->buildOtherWithProtocol(SALOME::CORBA_);
  79       MESSAGE("PROTOCOL CHANGED TO CORBA");
  80       sender->release();
  81       ret=getValueOneShot(newSender,size);
  82       CORBA::release(newSender);
  83     }
  84   return ret;
  85 }
  86
  87 /*!
  88   This method performs the transfert with the remote SenderDouble given. If it fails an exception is thrown.
  89  */
  90 double *ReceiverFactory::getValueOneShot(SALOME::SenderDouble_ptr sender,long &size)throw(MultiCommException)
  91 {
  92   SALOME::CorbaDoubleNCSender_ptr cncD_ptr;
  93   SALOME::CorbaDoubleCSender_ptr cwcD_ptr;
  94 #ifdef HAVE_MPI2
  95   SALOME::MPISenderDouble_ptr mpi_ptr=SALOME::MPISenderDouble::_narrow(sender);
  96 #endif
  97 #ifdef HAVE_SOCKET
  98   SALOME::SocketSenderDouble_ptr sock_ptr=SALOME::SocketSenderDouble::_narrow(sender);
  99 #endif
 100   cncD_ptr=SALOME::CorbaDoubleNCSender::_narrow(sender);
 101   cwcD_ptr=SALOME::CorbaDoubleCSender::_narrow(sender);
 102   if(!CORBA::is_nil(cncD_ptr))
 103     {
 104       CORBA::release(sender);
 105       CorbaDNoCopyReceiver<double,CORBA::Double,SALOME::vectorOfDouble_var,SALOME::CorbaDoubleNCSender_ptr,SALOME::SenderDouble_ptr,SALOME_SenderDouble_i> rec(cncD_ptr);
 106       return rec.getValue(size);
 107     }
 108   else if(!CORBA::is_nil(cwcD_ptr))
 109     {
 110       CORBA::release(sender);
 111       CorbaDWithCopyReceiver<double,CORBA::Double,SALOME::vectorOfDouble_var,SALOME::CorbaDoubleCSender_ptr,SALOME::SenderDouble_ptr,SALOME_SenderDouble_i> rec(cwcD_ptr);
 112       return rec.getValue(size);
 113     }
 114 #ifdef HAVE_MPI2
 115   else if(!CORBA::is_nil(mpi_ptr))
 116     {
 117       CORBA::release(sender);
 118       MPIReceiver<double,SALOME::MPISenderDouble_ptr,SALOME::SenderDouble_ptr,SALOME_SenderDouble_i> rec(mpi_ptr);
 119       return rec.getValue(size);
 120     }
 121 #endif
 122 #ifdef HAVE_SOCKET
 123   else if(!CORBA::is_nil(sock_ptr))
 124     {
 125       CORBA::release(sender);
 126       SocketReceiver<double,xdr_double,SALOME::SocketSenderDouble_ptr,SALOME::SenderDouble_ptr,SALOME_SenderDouble_i> rec(sock_ptr);
 127       return rec.getValue(size);
 128     }
 129 #endif
 130   else
 131     {
 132       throw MultiCommException("Unknown sender protocol");
 133       return 0;
 134     }
 135 }
 136
 137 /*!
 138   This method performs the transfert with the remote SenderInt given. If it fails an exception is thrown.
 139  */
 140 int *ReceiverFactory::getValueOneShot(SALOME::SenderInt_ptr sender,long &size)throw(MultiCommException)
 141 {
 142   SALOME::CorbaLongNCSender_ptr cncL_ptr;
 143   SALOME::CorbaLongCSender_ptr cwcL_ptr;
 144 #ifdef HAVE_MPI2
 145   SALOME::MPISenderInt_ptr mpi_ptr=SALOME::MPISenderInt::_narrow(sender);
 146 #endif
 147 #ifdef HAVE_SOCKET
 148   SALOME::SocketSenderInt_ptr sock_ptr=SALOME::SocketSenderInt::_narrow(sender);
 149 #endif
 150   cncL_ptr=SALOME::CorbaLongNCSender::_narrow(sender);
 151   cwcL_ptr=SALOME::CorbaLongCSender::_narrow(sender);
 152   if(!CORBA::is_nil(cncL_ptr))
 153     {
 154       CORBA::release(sender);
 155       CorbaINoCopyReceiver<int,CORBA::Long,SALOME::vectorOfLong_var,SALOME::CorbaLongNCSender_ptr,SALOME::SenderInt_ptr,SALOME_SenderInt_i> rec(cncL_ptr);
 156       return rec.getValue(size);
 157     }
 158   else if(!CORBA::is_nil(cwcL_ptr))
 159     {
 160       CORBA::release(sender);
 161       CorbaIWithCopyReceiver<int,CORBA::Long,SALOME::vectorOfLong_var,SALOME::CorbaLongCSender_ptr,SALOME::SenderInt_ptr,SALOME_SenderInt_i> rec(cwcL_ptr);
 162       return rec.getValue(size);
 163     }
 164 #ifdef HAVE_MPI2
 165   else if(!CORBA::is_nil(mpi_ptr))
 166     {
 167       CORBA::release(sender);
 168       MPIReceiver<int,SALOME::MPISenderInt_ptr,SALOME::SenderInt_ptr,SALOME_SenderInt_i> rec(mpi_ptr);
 169       return rec.getValue(size);
 170     }
 171 #endif
 172 #ifdef HAVE_SOCKET
 173   else if(!CORBA::is_nil(sock_ptr))
 174     {
 175       CORBA::release(sender);
 176       SocketReceiver<int,xdr_int,SALOME::SocketSenderInt_ptr,SALOME::SenderInt_ptr,SALOME_SenderInt_i> rec(sock_ptr);
 177       return rec.getValue(size);
 178     }
 179 #endif
 180   else
 181     {
 182       throw MultiCommException("Unknown sender protocol");
 183       return 0;
 184     }
 185 }
 186