MAK RTIspy API Documentation for HLA Evolved
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
forwarderPort.h
Go to the documentation of this file.
1 /*******************************************************************************
2 ** Copyright (c) 2005 MaK Technologies, Inc.
3 ** All rights reserved.
4 *******************************************************************************/
5 /*******************************************************************************
6 ** $RCSfile: forwarderPort.h,v $ $Revision: 1.18 $ $State: Exp $
7 *******************************************************************************/
10 
11 #ifndef DtForwarderPort_H_
12 #define DtForwarderPort_H_
13 
14 #include "routeMap.h"
15 #include "rtiMsConfig.h"
16 #include "rtiVersion.h"
17 
18 #include <vlutil/vlConfig.h>
19 #include <vlutil/vlUtil.h>
20 #include <vlutil/vlSelectParamW.h>
21 #include <vlutil/vlFedTarget.h>
22 #include <vlutil/vlInetAddr.h>
23 #include <map>
24 #include <vector>
25 #include <algorithm>
26 
27 class DtRIDParameters;
28 class DtRouteMap;
29 class DtTcpMsgSocket;
30 
35 class DT_DLL_FORWARDER DtForwarderPort
36 {
37 public:
38 
40  typedef DtForwarderPort* (*DtForwarderPortCreatorFcn)( const DtRIDParameters*,
41  const DtBoost::shared_ptr<DtRouteMap>,
42  const MAKRti::DtInetAddr&, int, const MAKRti::DtInetEndpoint& );
43 
44  struct DtForwarderMsg
45  {
46  caddr_t msg;
47  int length;
48  MAKRti::DtTransportType transport;
49  };
50 
51  typedef DtRouteMap::DtAddressPortList DtAddressPortList;
52  typedef DtRouteMap::DtAddressList DtAddressList;
53  typedef DtRouteMap::DtInterfaceAddrSet DtInterfaceAddrSet;
54  typedef std::vector<DtTcpMsgSocket*> DtSocketList;
55  typedef std::set<DtTcpMsgSocket*> DtSocketSet;
56  typedef std::pair< DtInetAddrAndPort, DtForwarderMsg > DtAddressMsgPair;
57  typedef std::pair<DtTcpMsgSocket*, DtForwarderMsg> DtSockMsgPair;
58  typedef std::map< DtInetAddrAndPort, DtTcpMsgSocket* > DtAddrToConnMap;
59  typedef std::map<DtInetAddrAndPort, MAKRti::DtString> DtConnAndNameMap;
60 
61  typedef int (*DtConnectionAddRemoveCb)(const MAKRti::DtString&,
62  const MAKRti::DtString&, unsigned int, const std::pair<DtInetAddrAndPort, DtInetAddrAndPort>&, void*);
63  typedef int(*DtConnectionReconnectBegunCb)(const MAKRti::DtString&,
64  const MAKRti::DtString&, unsigned int, const DtInetAddrAndPort&, void*);
65  typedef int(*DtConnectionReconnectCompleteCb)(const MAKRti::DtString&,
66  const MAKRti::DtString&, unsigned int, const DtInetAddrAndPort&, bool, void*);
67  typedef int (*DtConnectionChangeCb)(const MAKRti::DtString& ,
68  const MAKRti::DtString&, unsigned int, unsigned int, const DtInetAddrAndPort&, void*);
69  typedef void (*DtFederateAddedCb)(const MAKRti::DtString&,
70  const MAKRti::DtString&, const MAKRti::DtString&, unsigned int,
71  unsigned int, const DtInetAddrAndPort&, const MAKRti::DtString&,
72  unsigned int, const MAKRti::DtString&, const MAKRti::DtString&,
73  DtHlaVersionId, void*);
74  typedef void (*DtFederateRemovedCb)(const MAKRti::DtString&,
75  const MAKRti::DtString&, unsigned int, unsigned int,
76  const DtInetAddrAndPort&, void*);
77  typedef void (*DtPortReadyCb)(unsigned long, void*);
78  typedef int (*DtExecAddChangeCb)(const MAKRti::DtString&, unsigned int,
79  const DtInetAddrAndPort&, const MAKRti::DtString&, bool, void*);
80  typedef int (*DtExecRemovedChangeCb)(const MAKRti::DtString&, unsigned int,
81  const DtInetAddrAndPort&, void*);
82  typedef int (*DtSocketQueueCb)(unsigned int, int, void*);
83  typedef void (*DtWaitingForFwsCb)(const DtConnAndNameMap&,
84  const DtConnAndNameMap&, void*);
85  typedef void (*DtNotWaitingForFwsCb)(void*);
86  typedef std::vector< std::pair< DtConnectionAddRemoveCb, void* > > DtConnectionAddRemoveCallbackList;
87  typedef std::vector< std::pair< DtConnectionReconnectBegunCb, void* > > DtConnectionReconnectBegunCallbackList;
88  typedef std::vector< std::pair< DtConnectionReconnectCompleteCb, void* > > DtConnectionReconnectCompleteCallbackList;
89  typedef std::vector< std::pair< DtConnectionChangeCb, void* > > DtConnectionChangeCallbackList;
90  typedef std::vector< std::pair< DtFederateAddedCb, void* > > DtFederateAddedCallbackList;
91  typedef std::vector< std::pair< DtFederateRemovedCb, void* > > DtFederateRemovedCallbackList;
92  typedef std::vector< std::pair< DtPortReadyCb, void*> > DtPortReadyCallbackList;
93  typedef std::vector< std::pair< DtExecAddChangeCb, void* > > DtExecAddedCallbackList;
94  typedef std::vector< std::pair< DtExecRemovedChangeCb, void* > > DtExecRemovedCallbackList;
95  typedef std::vector< std::pair< DtSocketQueueCb, void* > > DtSocketQueueCallbackList;
96  typedef std::vector< std::pair< DtWaitingForFwsCb, void* > > DtWaitingForFwsCallbackList;
97  typedef std::vector< std::pair< DtNotWaitingForFwsCb, void* > > DtNotWaitingForFwsCallbackList;
98 
99 protected:
100  DtForwarderPort( const DtRIDParameters* params, DtBoost::shared_ptr<DtRouteMap> routes,
101  MAKRti::DtInetAddr host, int forwarderPort, MAKRti::DtInetEndpoint addnlConnection ) :
102  myParams( params ), myRoutes( routes ), myAddress( host ), myOk( true ),
103  myPortToUse(forwarderPort), myAdditionalAddrToConnectTo(addnlConnection)
104  {}
105 
106 public:
107  virtual ~DtForwarderPort() {};
108 
110  virtual bool isOk() const { return myOk; }
111 
113  virtual bool isReady() const = 0;
114 
116  virtual DtAddressMsgPair getNextMsg() = 0;
117 
119  virtual void sendByTransport( const DtForwarderMsg& msg ) const = 0;
120 
122  virtual void sendToAllReliable( const DtForwarderMsg& msg ) const = 0;
123 
126  virtual void sendToListReliable( const DtForwarderMsg& msg,
127  const DtRouteMap::DtAddressPortList& destinations ) const = 0;
128 
130  virtual inline bool flush();
131 
133  virtual void selectParams( MAKRti::DtSelectParamWithWrite& selectParams ) = 0;
134 
136  virtual void updateRoutes() = 0;
137 
140  virtual int checkConnectionStatus( const DtInetAddrAndPort* target = 0 ) = 0;
141 
143  virtual void clearNeededConnections() = 0;
144 
146  virtual unsigned int abortPendingConnections() = 0;
147 
149  virtual unsigned int pendingConnectionsAborted() = 0;
150 
152  virtual DtAddressPortList connections() const = 0;
153 
155 
156  virtual void listenToMulticastGroup( const MAKRti::DtInetAddr& mcastAddr ) = 0;
157  virtual void dropMulticastGroup( const MAKRti::DtInetAddr& mcastAddr ) = 0;
159 
161  virtual bool updateFederateConnectionId( unsigned long orig,
162  unsigned long final ) = 0;
163 
165 
166  virtual inline void addConnectionEstablishedCb( DtConnectionAddRemoveCb callback, void* usr );
167  virtual inline void removeConnectionEstablishedCb( DtConnectionAddRemoveCb callback, void* usr );
168  virtual inline void addConnectionLostCb( DtConnectionAddRemoveCb callback, void* usr );
169  virtual inline void removeConnectionLostCb( DtConnectionAddRemoveCb callback, void* usr );
170  virtual inline void addConnectionChangedCb( DtConnectionChangeCb callback, void* usr );
171  virtual inline void removeConnectionChangedCb( DtConnectionChangeCb callback, void* usr );
172 
173  virtual inline void addReconnectBegun(DtConnectionReconnectBegunCb callback, void* usr);
174  virtual inline void removeReconnectBegun(DtConnectionReconnectBegunCb callback, void* usr);
175  virtual inline void addReconnectComplete(DtConnectionReconnectCompleteCb callback, void* usr);
176  virtual inline void removeReconnectComplete(DtConnectionReconnectCompleteCb callback, void* usr);
178 
180 
181  virtual inline void addForwarderPortReadyCb( DtPortReadyCb callback, void* usr );
182  virtual inline void removeForwarderPortReadyCb( DtPortReadyCb callback, void* usr );
184 
186 
187  virtual inline void addFederateJoinedCb( DtFederateAddedCb callback, void* usr );
188  virtual inline void removeFederateJoinedCb( DtFederateAddedCb callback, void* usr );
189  virtual inline void addFederateResignedCb( DtFederateRemovedCb callback, void* usr );
190  virtual inline void removeFederateResignedCb( DtFederateRemovedCb callback, void* usr );
192 
194 
195  virtual inline void addSocketQueueCb( DtSocketQueueCb callback, void* usr );
196  virtual inline void removeSocketQueueCb( DtSocketQueueCb callback, void* usr );
198 
201 
202  virtual inline void addWaitingForForwarderConnectionsCb(DtWaitingForFwsCb callback, void* usr);
203  virtual inline void removeWaitingForForwarderConnectionsCb(DtWaitingForFwsCb callback, void* usr);
204  virtual inline void addNotWaitingForForwarderConnectionsCb(DtNotWaitingForFwsCb callback, void* usr);
205  virtual inline void removeNotWaitingForForwarderConnectionsCb(DtNotWaitingForFwsCb callback, void* usr);
207 
209 
210  virtual inline void addExecConnectionEstablishedCb(DtExecAddChangeCb callback, void* usr);
211  virtual inline void removeExecConnectionEstablishedCb(DtExecAddChangeCb callback, void * usr);
212  virtual inline void addExecDisconnectedCb(DtExecRemovedChangeCb callback, void* usr);
213  virtual inline void removeExecDisconnectedCb(DtExecRemovedChangeCb callback, void* usr);
215 
220  virtual void setForwarderId(unsigned long id);
221 
224 
225  virtual int execConnected( const MAKRti::DtString& connName,
226  unsigned int connID, const DtInetAddrAndPort& addr, const MAKRti::DtString& hostName,
227  bool fullyCompliant);
228  virtual int execDisconnected( const MAKRti::DtString& connName,
229  unsigned int connID, const DtInetAddrAndPort& addr );
231 
232 protected:
233 
236 
237  virtual inline int connectionEstablished( const MAKRti::DtString& connName,
238  const MAKRti::DtString& hostName, unsigned int connID, const std::pair<DtInetAddrAndPort, DtInetAddrAndPort>& addr);
239  virtual inline int connectionLost( const MAKRti::DtString& connName,
240  const MAKRti::DtString& hostName, unsigned int connID, const std::pair<DtInetAddrAndPort, DtInetAddrAndPort>& addr);
241  virtual inline int connectionChanged( const MAKRti::DtString& connName,
242  const MAKRti::DtString& hostName, unsigned int oldConnID, unsigned int newConnID, const DtInetAddrAndPort& addr );
243  inline int reconnectBegun(const MAKRti::DtString& connName,
244  const MAKRti::DtString& hostName, unsigned int connID, const DtInetAddrAndPort& addr);
245  inline int reconnectComplete(const MAKRti::DtString& connName,
246  const MAKRti::DtString& hostName, unsigned int connID, const DtInetAddrAndPort& addr, bool wasSuccessful);
248 
251  virtual void forwarderNodeIsReady(unsigned long id);
252 
255  virtual int socketQueueStatus( unsigned int connId, int connQueueStatus );
256 
261  virtual void waitingForForwarderConnections(const DtConnAndNameMap& allNeededFws,
262  const DtConnAndNameMap& stillNeededFws);
263 
266  virtual void notWaitingForForwarderConnections();
267 
270 
271  virtual void federateResigned( const MAKRti::DtString& connName,
272  const MAKRti::DtString& connType,unsigned int connID,
273  unsigned int fedHandle, const DtInetAddrAndPort& addr );
274  virtual void federateJoined( const MAKRti::DtString& connName,
275  const MAKRti::DtString& connType,
276  const MAKRti::DtString& federationName, unsigned int connID,
277  unsigned int fedHandle, const DtInetAddrAndPort& addr,
278  const MAKRti::DtString& hostName, unsigned int processId,
279  const MAKRti::DtString& processName,
280  const MAKRti::DtString& commandArgs, DtHlaVersionId hlaVersion );
282 
283 protected:
284 
286 
287  static int connectionEstablished( const MAKRti::DtString& connName,
288  const MAKRti::DtString& hostName, unsigned int connID, const std::pair<DtInetAddrAndPort, DtInetAddrAndPort>& addr, void* usr);
289  static int connectionLost( const MAKRti::DtString& connName,
290  const MAKRti::DtString& hostName, unsigned int connID, const std::pair<DtInetAddrAndPort, DtInetAddrAndPort>& addr, void* usr);
291  static int connectionChanged( const MAKRti::DtString& connName,
292  const MAKRti::DtString& hostName, unsigned int oldConnID, unsigned int newConnID,
293  const DtInetAddrAndPort& addr, void* usr );
295 
297 
298  static void federateJoined( const MAKRti::DtString& connName,
299  const MAKRti::DtString& connType,
300  const MAKRti::DtString& federationName, unsigned int connID,
301  unsigned int fedHandle, const DtInetAddrAndPort& addr,
302  const MAKRti::DtString& hostName, unsigned int processId,
303  const MAKRti::DtString& processName, const MAKRti::DtString& commandArgs,
304  DtHlaVersionId hlaVersion, void* usr);
305  static void federateResigned( const MAKRti::DtString& connName,
306  const MAKRti::DtString& connType,unsigned int connID,
307  unsigned int fedHandle, const DtInetAddrAndPort& addr, void* usr);
309 
311 
312  static int execConnected( const MAKRti::DtString& connName,
313  unsigned int connID, const DtInetAddrAndPort& addr,
314  const MAKRti::DtString& hostName, bool fullyCompliant, void* usr);
315  static int execDisconnected( const MAKRti::DtString& connName,
316  unsigned int connID, const DtInetAddrAndPort& addr, void* usr);
318 
320  static int socketQueueStatus( unsigned int connId, int connQueueStatus,
321  void* usr );
322 
324  static void forwarderNodeIsReady( unsigned long id, void* usr);
325 
326 protected:
327 
328  const DtRIDParameters* myParams;
329  DtBoost::shared_ptr<DtRouteMap> myRoutes;
330  const MAKRti::DtInetAddr myAddress;
331  bool myOk;
332 
333  int myPortToUse;
334  MAKRti::DtInetEndpoint myAdditionalAddrToConnectTo;
335 
336  DtConnectionAddRemoveCallbackList myConnectionEstablishedCbs;
337  DtConnectionAddRemoveCallbackList myConnectionLostCbs;
338  DtConnectionReconnectBegunCallbackList myReconnectBegunCbs;
339  DtConnectionReconnectCompleteCallbackList myReconnectCompleteCbs;
340  DtConnectionChangeCallbackList myConnectionChangedCbs;
341  DtFederateAddedCallbackList myFederateJoinedCbs;
342  DtFederateRemovedCallbackList myFederateResignedCbs;
343  DtPortReadyCallbackList myPortReadyCbs;
344  DtExecAddedCallbackList myExecConnectedCbs;
345  DtExecRemovedCallbackList myExecDisconnectedCbs;
346  DtSocketQueueCallbackList mySocketQueueCbs;
347  DtWaitingForFwsCallbackList myWaitingForFwsCbs;
348  DtNotWaitingForFwsCallbackList myNotWaitingForFwsCbs;
349 };
350 
351 inline bool DtForwarderPort::flush()
352 {
353  return false;
354 }
355 
356 
357 inline void DtForwarderPort::setForwarderId(unsigned long id)
358 {
359  // Do nothing.
360  return;
361 }
362 
363 inline void DtForwarderPort::addConnectionEstablishedCb( DtConnectionAddRemoveCb callback, void* usr )
364 {
366  std::pair<DtConnectionAddRemoveCb, void*> cbPair( callback, usr );
367  DtConnectionAddRemoveCallbackList::iterator pos = std::find( myConnectionEstablishedCbs.begin(),
368  myConnectionEstablishedCbs.end(), cbPair);
369  if ( pos == myConnectionEstablishedCbs.end() )
370  {
371  myConnectionEstablishedCbs.push_back( cbPair );
372  }
373 }
374 
375 inline void DtForwarderPort::removeConnectionEstablishedCb( DtConnectionAddRemoveCb callback, void* usr )
376 {
377  DtConnectionAddRemoveCallbackList::iterator pos = std::find( myConnectionEstablishedCbs.begin(),
378  myConnectionEstablishedCbs.end(), std::make_pair( callback, usr ));
379  if ( pos != myConnectionEstablishedCbs.end() ) myConnectionEstablishedCbs.erase( pos );
380 }
381 
382 
383 inline int DtForwarderPort::connectionEstablished( const MAKRti::DtString& connName,
384  const MAKRti::DtString& hostName, unsigned int connID, const std::pair<DtInetAddrAndPort, DtInetAddrAndPort>& addr)
385 {
386  int retVal = 0;
387  for ( DtConnectionAddRemoveCallbackList::iterator iter = myConnectionEstablishedCbs.begin();
388  iter != myConnectionEstablishedCbs.end(); ++iter )
389  {
390  if (-1 == ( *iter->first )( connName, hostName, connID, addr, iter->second ))
391  {
392  retVal = -1;
393  }
394  }
395  return retVal;
396 }
397 
398 inline void DtForwarderPort::addConnectionLostCb( DtConnectionAddRemoveCb callback, void* usr )
399 {
401  std::pair<DtConnectionAddRemoveCb, void*> cbPair( callback, usr );
402  DtConnectionAddRemoveCallbackList::iterator pos = std::find( myConnectionLostCbs.begin(),
403  myConnectionLostCbs.end(), cbPair);
404  if ( pos == myConnectionLostCbs.end() )
405  {
406  myConnectionLostCbs.push_back( cbPair );
407  }
408 }
409 
410 inline void DtForwarderPort::removeConnectionLostCb( DtConnectionAddRemoveCb callback, void* usr )
411 {
412  DtConnectionAddRemoveCallbackList::iterator pos = std::find( myConnectionLostCbs.begin(),
413  myConnectionLostCbs.end(), std::make_pair( callback, usr ));
414  if ( pos != myConnectionLostCbs.end() ) myConnectionLostCbs.erase( pos );
415 }
416 
417 inline int DtForwarderPort::connectionLost( const MAKRti::DtString& connName,
418  const MAKRti::DtString& hostName, unsigned int connID, const std::pair<DtInetAddrAndPort, DtInetAddrAndPort>& addr)
419 {
420  int retVal(0);
421  for ( DtConnectionAddRemoveCallbackList::iterator iter = myConnectionLostCbs.begin();
422  iter != myConnectionLostCbs.end(); ++iter )
423  {
424  if ( -1 == ( *iter->first )( connName, hostName, connID, addr, iter->second ) )
425  {
426  retVal = -1;
427  }
428  }
429  return retVal;
430 }
431 inline int DtForwarderPort::reconnectBegun(const MAKRti::DtString& connName,
432  const MAKRti::DtString& hostName, unsigned int connID, const DtInetAddrAndPort& addr)
433 {
434  int retVal(0);
435  for (DtConnectionReconnectBegunCallbackList::iterator iter = myReconnectBegunCbs.begin();
436  iter != myReconnectBegunCbs.end(); ++iter)
437  {
438  if (-1 == (*iter->first)(connName, hostName, connID, addr, iter->second))
439  {
440  retVal = -1;
441  }
442  }
443  return retVal;
444 }
445 inline int DtForwarderPort::reconnectComplete(const MAKRti::DtString& connName,
446  const MAKRti::DtString& hostName, unsigned int connID, const DtInetAddrAndPort& addr, bool wasSuccessful)
447 {
448  int retVal(0);
449  for (DtConnectionReconnectCompleteCallbackList::iterator iter = myReconnectCompleteCbs.begin();
450  iter != myReconnectCompleteCbs.end(); ++iter)
451  {
452  if (-1 == (*iter->first)(connName, hostName, connID, addr, wasSuccessful, iter->second))
453  {
454  retVal = -1;
455  }
456  }
457  return retVal;
458 }
459 inline void DtForwarderPort::addConnectionChangedCb( DtConnectionChangeCb callback, void* usr )
460 {
462  std::pair<DtConnectionChangeCb, void*> cbPair( callback, usr );
463  DtConnectionChangeCallbackList::iterator pos = std::find( myConnectionChangedCbs.begin(),
464  myConnectionChangedCbs.end(), cbPair);
465  if ( pos == myConnectionChangedCbs.end() )
466  {
467  myConnectionChangedCbs.push_back( cbPair );
468  }
469 }
470 
471 inline void DtForwarderPort::removeConnectionChangedCb( DtConnectionChangeCb callback, void* usr )
472 {
473  DtConnectionChangeCallbackList::iterator pos = std::find( myConnectionChangedCbs.begin(),
474  myConnectionChangedCbs.end(), std::make_pair( callback, usr ));
475  if ( pos != myConnectionChangedCbs.end() ) myConnectionChangedCbs.erase( pos );
476 }
477 
478 inline void DtForwarderPort::addReconnectBegun(DtConnectionReconnectBegunCb callback, void* usr)
479 {
481  std::pair<DtConnectionReconnectBegunCb, void*> cbPair(callback, usr);
482  DtConnectionReconnectBegunCallbackList::iterator pos = std::find(myReconnectBegunCbs.begin(),
483  myReconnectBegunCbs.end(), cbPair);
484  if (pos == myReconnectBegunCbs.end())
485  {
486  myReconnectBegunCbs.push_back(cbPair);
487  }
488 }
489 inline void DtForwarderPort::removeReconnectBegun(DtConnectionReconnectBegunCb callback, void* usr)
490 {
491  DtConnectionReconnectBegunCallbackList::iterator pos = std::find(myReconnectBegunCbs.begin(),
492  myReconnectBegunCbs.end(), std::make_pair(callback, usr));
493  if (pos != myReconnectBegunCbs.end()) myReconnectBegunCbs.erase(pos);
494 }
495 inline void DtForwarderPort::addReconnectComplete(DtConnectionReconnectCompleteCb callback, void* usr)
496 {
498  std::pair<DtConnectionReconnectCompleteCb, void*> cbPair(callback, usr);
499  DtConnectionReconnectCompleteCallbackList::iterator pos = std::find(myReconnectCompleteCbs.begin(),
500  myReconnectCompleteCbs.end(), cbPair);
501  if (pos == myReconnectCompleteCbs.end())
502  {
503  myReconnectCompleteCbs.push_back(cbPair);
504  }
505 }
506 inline void DtForwarderPort::removeReconnectComplete(DtConnectionReconnectCompleteCb callback, void* usr)
507 {
508  DtConnectionReconnectCompleteCallbackList::iterator pos = std::find(myReconnectCompleteCbs.begin(),
509  myReconnectCompleteCbs.end(), std::make_pair(callback, usr));
510  if (pos != myReconnectCompleteCbs.end()) myReconnectCompleteCbs.erase(pos);
511 }
512 
513 inline int DtForwarderPort::connectionChanged( const MAKRti::DtString& connName,
514  const MAKRti::DtString& hostName, unsigned int oldConnID, unsigned int newConnID,
515  const DtInetAddrAndPort& addr )
516 {
517  int retVal = 0;
518  for ( DtConnectionChangeCallbackList::iterator iter = myConnectionChangedCbs.begin();
519  iter != myConnectionChangedCbs.end(); ++iter )
520  {
521  if (-1 == ( *iter->first )( connName, hostName, oldConnID, newConnID, addr, iter->second ))
522  {
523  retVal = -1;
524  }
525  }
526  return retVal;
527 }
528 
529 inline void DtForwarderPort::addFederateResignedCb( DtFederateRemovedCb callback, void* usr )
530 {
532  std::pair<DtFederateRemovedCb, void*> cbPair( callback, usr );
533  DtFederateRemovedCallbackList::iterator pos = std::find( myFederateResignedCbs.begin(),
534  myFederateResignedCbs.end(), cbPair);
535  if ( pos == myFederateResignedCbs.end() )
536  {
537  myFederateResignedCbs.push_back( cbPair );
538  }
539 }
540 
541 inline void DtForwarderPort::removeFederateResignedCb( DtFederateRemovedCb callback, void* usr )
542 {
543  DtFederateRemovedCallbackList::iterator pos = std::find( myFederateResignedCbs.begin(),
544  myFederateResignedCbs.end(), std::make_pair( callback, usr ));
545  if ( pos != myFederateResignedCbs.end() ) myFederateResignedCbs.erase( pos );
546 }
547 
548 inline void DtForwarderPort::addSocketQueueCb( DtSocketQueueCb callback, void* usr )
549 {
551  std::pair< DtSocketQueueCb, void* > cbPair( callback, usr );
552 
553  DtSocketQueueCallbackList::iterator pos = std::find( mySocketQueueCbs.begin(),
554  mySocketQueueCbs.end(), cbPair );
555 
556  if( pos == mySocketQueueCbs.end() )
557  mySocketQueueCbs.push_back( cbPair );
558 }
559 
560 inline void DtForwarderPort::removeSocketQueueCb( DtSocketQueueCb callback, void* usr )
561 {
562  DtSocketQueueCallbackList::iterator pos = std::find( mySocketQueueCbs.begin(),
563  mySocketQueueCbs.end(), std::make_pair( callback, usr ));
564 
565  if( pos != mySocketQueueCbs.end() )
566  mySocketQueueCbs.erase( pos );
567 }
568 
569 inline void DtForwarderPort::federateResigned( const MAKRti::DtString& connName, const MAKRti::DtString& connType, unsigned int connID,
570  unsigned int fedHandle, const DtInetAddrAndPort& addr )
571 {
572  for ( DtFederateRemovedCallbackList::iterator iter = myFederateResignedCbs.begin();
573  iter != myFederateResignedCbs.end(); ++iter )
574  {
575  ( *iter->first )( connName, connType, connID, fedHandle, addr, iter->second );
576  }
577 }
578 
579 inline void DtForwarderPort::federateResigned(const MAKRti::DtString& connName, const MAKRti::DtString& connType, unsigned int connID,
580  unsigned int fedHandle, const DtInetAddrAndPort& addr, void* usr)
581 {
582  ((DtForwarderPort*)usr)->federateResigned(connName, connType, connID, fedHandle, addr);
583 }
584 
585 inline void DtForwarderPort::addForwarderPortReadyCb( DtPortReadyCb callback, void* usr )
586 {
588  std::pair<DtPortReadyCb, void*> cbPair( callback, usr );
589  DtPortReadyCallbackList::iterator pos = std::find( myPortReadyCbs.begin(),
590  myPortReadyCbs.end(), cbPair);
591  if ( pos == myPortReadyCbs.end() )
592  {
593  myPortReadyCbs.push_back( cbPair );
594  }
595 }
596 
597 inline void DtForwarderPort::removeForwarderPortReadyCb( DtPortReadyCb callback, void* usr )
598 {
599  DtPortReadyCallbackList::iterator pos = std::find( myPortReadyCbs.begin(),
600  myPortReadyCbs.end(), std::make_pair( callback, usr ));
601  if ( pos != myPortReadyCbs.end() ) myPortReadyCbs.erase( pos );
602 }
603 
604 
605 inline void DtForwarderPort::forwarderNodeIsReady(unsigned long id, void* usr)
606 {
607  return (static_cast<DtForwarderPort*>(usr))->forwarderNodeIsReady(id);
608 }
609 
610 inline void DtForwarderPort::forwarderNodeIsReady(unsigned long id)
611 {
612  for ( DtPortReadyCallbackList::iterator iter = myPortReadyCbs.begin();
613  iter != myPortReadyCbs.end(); ++iter )
614  {
615  ( *iter->first )( id, iter->second);
616  }
617 }
618 
619 
620 
621 inline void DtForwarderPort::addFederateJoinedCb( DtFederateAddedCb callback, void* usr )
622 {
624  std::pair<DtFederateAddedCb, void*> cbPair( callback, usr );
625  DtFederateAddedCallbackList::iterator pos = std::find( myFederateJoinedCbs.begin(),
626  myFederateJoinedCbs.end(), cbPair);
627  if ( pos == myFederateJoinedCbs.end() )
628  {
629  myFederateJoinedCbs.push_back( cbPair );
630  }
631 }
632 
633 inline void DtForwarderPort::removeFederateJoinedCb( DtFederateAddedCb callback, void* usr )
634 {
635  DtFederateAddedCallbackList::iterator pos = std::find( myFederateJoinedCbs.begin(),
636  myFederateJoinedCbs.end(), std::make_pair( callback, usr ));
637  if ( pos != myFederateJoinedCbs.end() ) myFederateJoinedCbs.erase( pos );
638 }
639 
640 inline void DtForwarderPort::federateJoined(const MAKRti::DtString& connName,
641  const MAKRti::DtString& connType,
642  const MAKRti::DtString& federationName,
643  unsigned int connID,
644  unsigned int fedHandle,
645  const DtInetAddrAndPort& addr,
646  const MAKRti::DtString& hostName,
647  unsigned int processId,
648  const MAKRti::DtString& processName,
649  const MAKRti::DtString& commandArgs,
650  DtHlaVersionId hlaVersion )
651 {
652  for ( DtFederateAddedCallbackList::iterator iter = myFederateJoinedCbs.begin();
653  iter != myFederateJoinedCbs.end(); ++iter )
654  {
655  ( *iter->first )( connName, connType, federationName, connID, fedHandle,
656  addr, hostName, processId, processName, commandArgs, hlaVersion,
657  iter->second );
658  }
659 }
660 
661 inline void DtForwarderPort::federateJoined(const MAKRti::DtString& connName,
662  const MAKRti::DtString& connType,
663  const MAKRti::DtString& federationName,
664  unsigned int connID,
665  unsigned int fedHandle,
666  const DtInetAddrAndPort& addr,
667  const MAKRti::DtString& hostName,
668  unsigned int processId,
669  const MAKRti::DtString& processName,
670  const MAKRti::DtString& commandArgs,
671  DtHlaVersionId hlaVersion,
672  void* usr)
673 {
674  ((DtForwarderPort*)usr)->federateJoined(connName, connType, federationName,
675  connID, fedHandle, addr, hostName, processId, processName, commandArgs,
676  hlaVersion);
677 }
678 
679 
680 inline int DtForwarderPort::connectionEstablished( const MAKRti::DtString& connName,
681  const MAKRti::DtString& hostName,
682  unsigned int connID,
683  const std::pair<DtInetAddrAndPort, DtInetAddrAndPort>& addr,
684  void* usr )
685 {
686  return ((DtForwarderPort*)usr)->connectionEstablished(connName, hostName, connID, addr);
687 }
688 
689 inline int DtForwarderPort::connectionLost( const MAKRti::DtString& connName,
690  const MAKRti::DtString& hostName,
691  unsigned int connID,
692  const std::pair<DtInetAddrAndPort, DtInetAddrAndPort>& addr,
693  void* usr )
694 {
695  return ((DtForwarderPort*)usr)->connectionLost(connName, hostName, connID, addr);
696 }
697 
698 inline int DtForwarderPort::connectionChanged( const MAKRti::DtString& connName,
699  const MAKRti::DtString& hostName, unsigned int oldConnID, unsigned int newConnID,
700  const DtInetAddrAndPort& addr,
701  void* usr )
702 {
703  return ((DtForwarderPort*)usr)->connectionChanged(connName, hostName, oldConnID, newConnID, addr);
704 }
705 
706 inline void DtForwarderPort::addExecConnectionEstablishedCb( DtExecAddChangeCb callback, void* usr )
707 {
709  std::pair<DtExecAddChangeCb, void*> cbPair( callback, usr );
710  DtExecAddedCallbackList::iterator pos = std::find( myExecConnectedCbs.begin(),
711  myExecConnectedCbs.end(), cbPair);
712  if ( pos == myExecConnectedCbs.end() )
713  {
714  myExecConnectedCbs.push_back( cbPair );
715  }
716 }
717 
718 inline void DtForwarderPort::removeExecConnectionEstablishedCb( DtExecAddChangeCb callback, void* usr )
719 {
720  DtExecAddedCallbackList::iterator pos = std::find( myExecConnectedCbs.begin(),
721  myExecConnectedCbs.end(), std::make_pair( callback, usr ));
722  if ( pos != myExecConnectedCbs.end() )
723  {
724  myExecConnectedCbs.erase( pos );
725  }
726 }
727 
728 inline int DtForwarderPort::execConnected( const MAKRti::DtString& connName,
729  unsigned int connID,
730  const DtInetAddrAndPort& addr,
731  const MAKRti::DtString& hostName,
732  bool fullyCompliant, void* usr)
733 {
734  return ((DtForwarderPort*)usr)->execConnected(connName, connID, addr, hostName, fullyCompliant);
735 }
736 
737 inline int DtForwarderPort::execConnected( const MAKRti::DtString& connName,
738  unsigned int connID,
739  const DtInetAddrAndPort& addr,
740  const MAKRti::DtString& hostName,
741  bool fullyCompliant )
742 {
743  int retVal = 0;
744  for ( DtExecAddedCallbackList::iterator iter = myExecConnectedCbs.begin();
745  iter != myExecConnectedCbs.end(); ++iter )
746  {
747  if ( -1 == ( *iter->first )( connName, connID, addr, hostName, fullyCompliant, iter->second ) )
748  {
749  retVal = -1;
750  }
751  }
752  return retVal;
753 }
754 
755 
756 inline void DtForwarderPort::addExecDisconnectedCb( DtExecRemovedChangeCb callback, void* usr )
757 {
759  std::pair<DtExecRemovedChangeCb, void*> cbPair( callback, usr );
760  DtExecRemovedCallbackList::iterator pos = std::find( myExecDisconnectedCbs.begin(),
761  myExecDisconnectedCbs.end(), cbPair);
762  if ( pos == myExecDisconnectedCbs.end() )
763  {
764  myExecDisconnectedCbs.push_back( cbPair );
765  }
766 }
767 
768 inline void DtForwarderPort::removeExecDisconnectedCb( DtExecRemovedChangeCb callback, void* usr )
769 {
770  DtExecRemovedCallbackList::iterator pos = std::find( myExecDisconnectedCbs.begin(),
771  myExecDisconnectedCbs.end(), std::make_pair( callback, usr ));
772  if ( pos != myExecDisconnectedCbs.end() )
773  {
774  myExecDisconnectedCbs.erase( pos );
775  }
776 }
777 
778 inline int DtForwarderPort::execDisconnected(const MAKRti::DtString& connName,
779  unsigned int connID, const DtInetAddrAndPort& addr, void* usr)
780 {
781  return ((DtForwarderPort*)usr)->execDisconnected(connName, connID, addr);
782 }
783 
784 inline int DtForwarderPort::execDisconnected( const MAKRti::DtString& connName,
785  unsigned int connID, const DtInetAddrAndPort& addr)
786 {
787  int retVal = 0;
788  for ( DtExecRemovedCallbackList::iterator iter = myExecDisconnectedCbs.begin();
789  iter != myExecDisconnectedCbs.end(); ++iter )
790  {
791  if ( -1 == ( *iter->first )( connName, connID, addr, iter->second ) )
792  {
793  retVal = -1;
794  }
795  }
796  return retVal;
797 }
798 
799 inline void DtForwarderPort::addWaitingForForwarderConnectionsCb(DtWaitingForFwsCb callback, void* usr)
800 {
802  std::pair< DtWaitingForFwsCb, void* > cbPair( callback, usr );
803 
804  DtWaitingForFwsCallbackList::iterator pos = std::find( myWaitingForFwsCbs.begin(),
805  myWaitingForFwsCbs.end(), cbPair );
806 
807  if( pos == myWaitingForFwsCbs.end() )
808  {
809  myWaitingForFwsCbs.push_back( cbPair );
810  }
811 }
812 
813 inline void DtForwarderPort::removeWaitingForForwarderConnectionsCb(DtWaitingForFwsCb callback, void* usr)
814 {
815  DtWaitingForFwsCallbackList::iterator pos = std::find( myWaitingForFwsCbs.begin(),
816  myWaitingForFwsCbs.end(), std::make_pair( callback, usr ));
817 
818  if( pos != myWaitingForFwsCbs.end() )
819  {
820  myWaitingForFwsCbs.erase( pos );
821  }
822 }
823 
824 inline void DtForwarderPort::waitingForForwarderConnections(const DtConnAndNameMap& allNeededFws,
825  const DtConnAndNameMap& stillNeededFws)
826 {
827  for ( DtWaitingForFwsCallbackList::iterator iter = myWaitingForFwsCbs.begin();
828  iter != myWaitingForFwsCbs.end(); ++iter )
829  {
830  ( *iter->first )( allNeededFws, stillNeededFws, iter->second );
831  }
832 }
833 
834 inline void DtForwarderPort::addNotWaitingForForwarderConnectionsCb(DtNotWaitingForFwsCb callback, void* usr)
835 {
837  std::pair< DtNotWaitingForFwsCb, void* > cbPair( callback, usr );
838 
839  DtNotWaitingForFwsCallbackList::iterator pos = std::find( myNotWaitingForFwsCbs.begin(),
840  myNotWaitingForFwsCbs.end(), cbPair );
841 
842  if( pos == myNotWaitingForFwsCbs.end() )
843  {
844  myNotWaitingForFwsCbs.push_back( cbPair );
845  }
846 }
847 
848 inline void DtForwarderPort::removeNotWaitingForForwarderConnectionsCb(DtNotWaitingForFwsCb callback, void* usr)
849 {
850  DtNotWaitingForFwsCallbackList::iterator pos = std::find( myNotWaitingForFwsCbs.begin(),
851  myNotWaitingForFwsCbs.end(), std::make_pair( callback, usr ));
852 
853  if( pos != myNotWaitingForFwsCbs.end() )
854  {
855  myNotWaitingForFwsCbs.erase( pos );
856  }
857 }
858 
859 inline void DtForwarderPort::notWaitingForForwarderConnections()
860 {
861  for ( DtNotWaitingForFwsCallbackList::iterator iter = myNotWaitingForFwsCbs.begin();
862  iter != myNotWaitingForFwsCbs.end(); ++iter )
863  {
864  ( *iter->first )( iter->second );
865  }
866 }
867 
868 inline int DtForwarderPort::socketQueueStatus( unsigned int connId, int connQueueStatus, void* usr )
869 {
870  return ((DtForwarderPort*)usr)->socketQueueStatus( connId, connQueueStatus );
871 }
872 
873 inline int DtForwarderPort::socketQueueStatus( unsigned int connId, int connQueueStatus )
874 {
875  int retVal = 0;
876 
877  for( DtSocketQueueCallbackList::iterator iter = mySocketQueueCbs.begin();
878  iter != mySocketQueueCbs.end(); ++iter )
879  {
880  if( -1 == ( *iter->first )( connId, connQueueStatus, iter->second ) )
881  {
882  retVal = -1;
883  }
884  }
885 
886  return retVal;
887 }
888 
889 
890 #endif
891 
892 
Document ID: Generated on Mon Jul 9 10:30:41 EDT 2018 from SVN revision 190224
Copyright © 2005-2018 VT MÄK Inc. All Rights Reserved (www.mak.com)