-#include <rpc/xdr.h>
+// Copyright (C) 2007-2013 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
#include "SALOME_Comm_i.hxx"
-#include "poa.h"
+#ifndef WIN32
+#ifndef __APPLE__
+#include <rpc/xdr.h>
+#endif
+#endif
+#include "omniORB4/poa.h"
#include "omnithread.h"
#include "Utils_SINGLETON.hxx"
#include "Utils_ORB_INIT.hxx"
#include "utilities.h"
#include "SenderFactory.hxx"
-using namespace std;
+#ifndef WIN32
CORBA::ORB_var &getGlobalORB(){
ORB_INIT &init = *SINGLETON_<ORB_INIT>::Instance();
CORBA::ORB_var &orb = init(0,0);
return orb;
}
+#endif
/*! Return the C++ data associated to the array to transmit.
Used when sender and receiver are collocalized.
}
/*! Unique constructor */
-SALOME_Sender_i::SALOME_Sender_i(SALOME::TypeOfDataTransmitted type,const void *tabToSend,long lgrTabToSend,int sizeOf):_tabToSend(tabToSend),_lgrTabToSend(lgrTabToSend),_type(type),_sizeOf(sizeOf){
+SALOME_Sender_i::SALOME_Sender_i(const void *tabToSend,long lgrTabToSend,int sizeOf,bool ownTabToSend):_tabToSend(tabToSend),_lgrTabToSend(lgrTabToSend),_sizeOf(sizeOf),_ownTabToSend(ownTabToSend){
+}
+
+/*! To force ownerShip status */
+void SALOME_Sender_i::setOwnerShip(bool own)
+{
+ _ownTabToSend=own;
+}
+
+/*! Method for the remote destroy of the current servant. This method is used by the receiver to destroy the sender when the transfert is complete.
+ */
+void SALOME_Sender_i::release()
+{
+ PortableServer::ObjectId_var oid = _default_POA()->servant_to_id(this);
+ _default_POA()->deactivate_object(oid);
+ _remove_ref();
+}
+
+SALOME_SenderDouble_i::SALOME_SenderDouble_i(const double *tabToSend,long lgrTabToSend,bool ownTabToSend):SALOME_Sender_i(tabToSend,lgrTabToSend,sizeof(double),ownTabToSend)
+{
+}
+
+/*! Destructor.
+ */
+SALOME_SenderDouble_i::~SALOME_SenderDouble_i()
+{
+ if(_ownTabToSend)
+ delete [] (double *)_tabToSend;
+}
+
+/*! Return a new sender of the same array but with an another protocol and delegates to the returned sender the ownership of array.
+ */
+SALOME::SenderDouble_ptr SALOME_SenderDouble_i::buildOtherWithProtocol(SALOME::TypeOfCommunication type)
+{
+ return SenderFactory::buildSender(type,this);
}
/*! Method to establish if the CORBA object refered by pCorba is collocalised.\n
If it is, the pointer to the servant that incarnates the CORBA object is returned.
*/
-SALOME_Sender_i *SALOME_Sender_i::find(SALOME::Sender_ptr pCorba){
+SALOME_SenderDouble_i *SALOME_SenderDouble_i::find(SALOME::SenderDouble_ptr pCorba){
PortableServer::ServantBase *ret;
try {
ret=PortableServer::POA::_the_root_poa()->reference_to_servant(pCorba);
return 0;
}
ret->_remove_ref();
- return dynamic_cast<SALOME_Sender_i *>(ret);
+ return dynamic_cast<SALOME_SenderDouble_i *>(ret);
}
-/*! Method for the remote destroy of the current servant. This method is used by the receiver to destroy the sender when the transfert is complete.
- */
-void SALOME_Sender_i::release()
+SALOME_SenderInt_i::SALOME_SenderInt_i(const int *tabToSend,long lgrTabToSend,bool ownTabToSend):SALOME_Sender_i(tabToSend,lgrTabToSend,sizeof(int),ownTabToSend)
{
- PortableServer::ObjectId_var oid = _default_POA()->servant_to_id(this);
- _default_POA()->deactivate_object(oid);
- _remove_ref();
}
-/*! Return the type of the element that compose the array. Used by receiverfactory to build the correct receiver.
+/*! Destructor.
*/
-SALOME::TypeOfDataTransmitted SALOME_Sender_i::getTypeOfDataTransmitted()
+SALOME_SenderInt_i::~SALOME_SenderInt_i()
{
- return _type;
+ if(_ownTabToSend)
+ delete [] (int *)_tabToSend;
}
/*! Return a new sender of the same array but with an another protocol.
*/
-SALOME::Sender_ptr SALOME_Sender_i::buildOtherWithProtocol(SALOME::TypeOfCommunication type)
+SALOME::SenderInt_ptr SALOME_SenderInt_i::buildOtherWithProtocol(SALOME::TypeOfCommunication type)
{
return SenderFactory::buildSender(type,this);
}
-SALOME_CorbaDoubleNCSender_i::SALOME_CorbaDoubleNCSender_i(const double *tabToSend,long lgrTabToSend):SALOME_Sender_i(SALOME::DOUBLE_,tabToSend,lgrTabToSend,sizeof(double)){
+/*! Method to establish if the CORBA object refered by pCorba is collocalised.\n
+ If it is, the pointer to the servant that incarnates the CORBA object is returned.
+*/
+SALOME_SenderInt_i *SALOME_SenderInt_i::find(SALOME::SenderInt_ptr pCorba){
+ PortableServer::ServantBase *ret;
+ try {
+ ret=PortableServer::POA::_the_root_poa()->reference_to_servant(pCorba);
+ }
+ catch(...){
+ return 0;
+ }
+ ret->_remove_ref();
+ return dynamic_cast<SALOME_SenderInt_i *>(ret);
+}
+
+SALOME_CorbaDoubleNCSender_i::SALOME_CorbaDoubleNCSender_i(const double *tabToSend,long lgrTabToSend,bool ownTabToSend):SALOME_SenderDouble_i(tabToSend,lgrTabToSend,ownTabToSend),SALOME_Sender_i(tabToSend,lgrTabToSend,sizeof(double),ownTabToSend){
}
SALOME_CorbaDoubleNCSender_i::~SALOME_CorbaDoubleNCSender_i(){
return c1._retn();
}
-SALOME_CorbaDoubleCSender_i::SALOME_CorbaDoubleCSender_i(const double *tabToSend,long lgrTabToSend):SALOME_Sender_i(SALOME::DOUBLE_,tabToSend,lgrTabToSend,sizeof(double)){
+SALOME_CorbaDoubleCSender_i::SALOME_CorbaDoubleCSender_i(const double *tabToSend,long lgrTabToSend,bool ownTabToSend):SALOME_SenderDouble_i(tabToSend,lgrTabToSend,ownTabToSend),SALOME_Sender_i(tabToSend,lgrTabToSend,sizeof(double),ownTabToSend){
}
SALOME_CorbaDoubleCSender_i::~SALOME_CorbaDoubleCSender_i(){
////////////////////////
-SALOME_CorbaLongNCSender_i::SALOME_CorbaLongNCSender_i(const int *tabToSend,long lgrTabToSend):SALOME_Sender_i(SALOME::INT_,tabToSend,lgrTabToSend,sizeof(int)){
+SALOME_CorbaLongNCSender_i::SALOME_CorbaLongNCSender_i(const int *tabToSend,long lgrTabToSend,bool ownTabToSend):SALOME_SenderInt_i(tabToSend,lgrTabToSend,ownTabToSend),SALOME_Sender_i(tabToSend,lgrTabToSend,sizeof(int),ownTabToSend){
}
SALOME_CorbaLongNCSender_i::~SALOME_CorbaLongNCSender_i(){
return c1._retn();
}
-SALOME_CorbaLongCSender_i::SALOME_CorbaLongCSender_i(const int *tabToSend,long lgrTabToSend):SALOME_Sender_i(SALOME::INT_,tabToSend,lgrTabToSend,sizeof(int)){
+SALOME_CorbaLongCSender_i::SALOME_CorbaLongCSender_i(const int *tabToSend,long lgrTabToSend,bool ownTabToSend):SALOME_SenderInt_i(tabToSend,lgrTabToSend,ownTabToSend),SALOME_Sender_i(tabToSend,lgrTabToSend,sizeof(int),ownTabToSend){
}
SALOME_CorbaLongCSender_i::~SALOME_CorbaLongCSender_i(){
unsigned long SALOME_MPISender_i::_tag2=1;
-SALOME_MPISender_i::SALOME_MPISender_i(SALOME::TypeOfDataTransmitted type,const void *tabToSend,long lgrTabToSend,int sizeOf):SALOME_Sender_i(type,tabToSend,lgrTabToSend,sizeOf){
+SALOME_MPISender_i::SALOME_MPISender_i(const void *tabToSend,long lgrTabToSend,int sizeOf,bool ownTabToSend):SALOME_Sender_i(tabToSend,lgrTabToSend,sizeOf,ownTabToSend){
_portName=new char[MPI_MAX_PORT_NAME];
}
SALOME::MPISender::param* SALOME_MPISender_i::getParam()
{
char stag[12];
- int myproc,i=0;
+ int i=0;
SALOME::MPISender::param_var p = new SALOME::MPISender::param;
MPI_Comm_rank(MPI_COMM_WORLD,&_cproc);
void SALOME_MPISender_i::send()
{
- _argsForThr=new (void *)[8];
+ _type=getTypeOfDataTransmitted();
+ _argsForThr=new void *[8];
_argsForThr[0]=_portName;
_argsForThr[1]=&_lgrTabToSend;
_argsForThr[2]=(void *)_tabToSend;
MPI_Send(argsTab[2],*lgrTabToSend,MPI_INT,*cproc,*tag2,*com);
}
omni_thread::exit();
+ return args;
}
void SALOME_MPISender_i::close(const SALOME::MPISender::param& p)
{
std::string service(p.service);
- const char *st=p.service;
void *r;
_newThr->join(&r);
MPI_Comm_free(&_com);
delete [] _argsForThr;
}
+SALOME_MPISenderDouble_i::SALOME_MPISenderDouble_i(const double *tabToSend,long lgrTabToSend,bool ownTabToSend)
+ :SALOME_SenderDouble_i(tabToSend,lgrTabToSend,ownTabToSend),SALOME_MPISender_i(tabToSend,lgrTabToSend,sizeof(double),ownTabToSend)
+ ,SALOME_Sender_i(tabToSend,lgrTabToSend,sizeof(double),ownTabToSend)
+{
+}
+
+SALOME_MPISenderInt_i::SALOME_MPISenderInt_i(const int *tabToSend,long lgrTabToSend,bool ownTabToSend)
+ :SALOME_SenderInt_i(tabToSend,lgrTabToSend,ownTabToSend),SALOME_MPISender_i(tabToSend,lgrTabToSend,sizeof(int),ownTabToSend)
+ ,SALOME_Sender_i(tabToSend,lgrTabToSend,sizeof(int),ownTabToSend)
+{
+}
+
#endif
#ifdef HAVE_SOCKET
+//CCRT porting
+#define _POSIX_PII_SOCKET
+#define _LIBC_POLLUTION_H_
+
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <unistd.h>
-SALOME_SocketSender_i::SALOME_SocketSender_i(SALOME::TypeOfDataTransmitted type,const void *tabToSend,long lgrTabToSend,int sizeOf):SALOME_Sender_i(type,tabToSend,lgrTabToSend,sizeOf){
+SALOME_SocketSender_i::SALOME_SocketSender_i(const void *tabToSend,long lgrTabToSend,int sizeOf,bool ownTabToSend):SALOME_Sender_i(tabToSend,lgrTabToSend,sizeOf,ownTabToSend){
_IPAddress = inetAddress();
_serverSockfd = -1;
_clientSockfd = -1;
host = gethostbyname(s);
if (host != NULL)
inet_ntop(AF_INET, (struct in_addr *) *host->h_addr_list,
- t, INET_ADDRSTRLEN);
+ t, INET_ADDRSTRLEN);
}
return std::string(t);
}
void SALOME_SocketSender_i::send()
{
+ _type=getTypeOfDataTransmitted();
_argsForThr=new void *[6];
_argsForThr[0]=&_serverSockfd;
_argsForThr[1]=&_clientSockfd;
*errorFlag = false;
while( n < *lgrTabToSend*sizeof(double) ){
- m = write(*clientSockfd, (char*)tabToSend+n, *lgrTabToSend*sizeof(double)-n);
- if( m < 0 ){
- if( *clientSockfd >= 0 ){
- ::close(*clientSockfd);
- *clientSockfd = -1;
- }
- if( *serverSockfd >= 0 ){
- ::close(*serverSockfd);
- *serverSockfd = -1;
- }
- *errorFlag = true;
- }
- n += m;
+ m = write(*clientSockfd, (char*)tabToSend+n, *lgrTabToSend*sizeof(double)-n);
+ if( m < 0 ){
+ if( *clientSockfd >= 0 ){
+ ::close(*clientSockfd);
+ *clientSockfd = -1;
+ }
+ if( *serverSockfd >= 0 ){
+ ::close(*serverSockfd);
+ *serverSockfd = -1;
+ }
+ *errorFlag = true;
+ }
+ n += m;
}
xdr_destroy( &xp );
*errorFlag = false;
while( n < *lgrTabToSend*sizeof(int) ){
- m = write(*clientSockfd, (char*)tabToSend+n, *lgrTabToSend*sizeof(int)-n);
- if( m < 0 ){
- if( *clientSockfd >= 0 ){
- ::close(*clientSockfd);
- *clientSockfd = -1;
- }
- if( *serverSockfd >= 0 ){
- ::close(*serverSockfd);
- *serverSockfd = -1;
- }
- *errorFlag = true;
- }
- n += m;
+ m = write(*clientSockfd, (char*)tabToSend+n, *lgrTabToSend*sizeof(int)-n);
+ if( m < 0 ){
+ if( *clientSockfd >= 0 ){
+ ::close(*clientSockfd);
+ *clientSockfd = -1;
+ }
+ if( *serverSockfd >= 0 ){
+ ::close(*serverSockfd);
+ *serverSockfd = -1;
+ }
+ *errorFlag = true;
+ }
+ n += m;
}
xdr_destroy( &xp );
xdr_vector( &xp, (char*)tabToSend, *lgrTabToSend, sizeof(int), (xdrproc_t)xdr_int );
xdr_destroy( &xp );
}
+ return args;
}
void SALOME_SocketSender_i::initCom() throw(SALOME::SALOME_Exception)
/* Association of socket with a port */
if( ::bind(_serverSockfd, (struct sockaddr *) & serv_addr,
- sizeof(struct sockaddr)) < 0 ) {
+ sizeof(struct sockaddr)) < 0 ) {
closeCom();
es.type = SALOME::COMM;
es.text = "error bind Socket exception";
void SALOME_SocketSender_i::acceptCom() throw(SALOME::SALOME_Exception)
{
socklen_t sin_size;
- int new_fd;
struct sockaddr_in client_addr;
SALOME::ExceptionStruct es;
delete [] _argsForThr;
}
+SALOME_SocketSenderDouble_i::SALOME_SocketSenderDouble_i(const double *tabToSend,long lgrTabToSend,bool ownTabToSend)
+ :SALOME_SenderDouble_i(tabToSend,lgrTabToSend,ownTabToSend),SALOME_SocketSender_i(tabToSend,lgrTabToSend,sizeof(double),ownTabToSend)
+ ,SALOME_Sender_i(tabToSend,lgrTabToSend,sizeof(double),ownTabToSend)
+{
+}
+
+SALOME_SocketSenderInt_i::SALOME_SocketSenderInt_i(const int *tabToSend,long lgrTabToSend,bool ownTabToSend)
+ :SALOME_SenderInt_i(tabToSend,lgrTabToSend,ownTabToSend),SALOME_SocketSender_i(tabToSend,lgrTabToSend,sizeof(int),ownTabToSend)
+ ,SALOME_Sender_i(tabToSend,lgrTabToSend,sizeof(int),ownTabToSend)
+{
+}
+
+//CCRT porting
+#undef _LIBC_POLLUTION_H_
+#undef _POSIX_PII_SOCKET
+
#endif
