MAK RTIspy API Documentation for HLA 1.3
 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 
DtForwarderPort::DtInterfaceAddrSet
DtRouteMap::DtInterfaceAddrSet DtInterfaceAddrSet
Definition: forwarderPort.h:53
DtForwarderPort::DtSocketSet
std::set< DtTcpMsgSocket * > DtSocketSet
Definition: forwarderPort.h:55
DtForwarderPort::DtConnectionChangeCallbackList
std::vector< std::pair< DtConnectionChangeCb, void * > > DtConnectionChangeCallbackList
Definition: forwarderPort.h:89
DtInetAddrAndPort
std::pair< MAKRti::DtInetAddr, int > DtInetAddrAndPort
Definition: rtiUtil.h:147
DtForwarderPort::DtAddressList
DtRouteMap::DtAddressList DtAddressList
Definition: forwarderPort.h:52
DtForwarderPort::addSocketQueueCb
virtual void addSocketQueueCb(DtSocketQueueCb callback, void *usr)
Register/Unregister callback for event - socket queue status changes.
Definition: forwarderPort.h:548
DtForwarderPort::myExecConnectedCbs
DtExecAddedCallbackList myExecConnectedCbs
Definition: forwarderPort.h:344
DtForwarderPort::removeConnectionChangedCb
virtual void removeConnectionChangedCb(DtConnectionChangeCb callback, void *usr)
Register/Unregister callback for addition/removal/change of connections.
Definition: forwarderPort.h:471
DtForwarderPort::setForwarderId
virtual void setForwarderId(unsigned long id)
Set forwarder ID.
Definition: forwarderPort.h:357
DtForwarderPort::connectionChanged
virtual int connectionChanged(const MAKRti::DtString &connName, const MAKRti::DtString &hostName, unsigned int oldConnID, unsigned int newConnID, const DtInetAddrAndPort &addr)
Call when connection is added/removed/changed Invokes callbacks registered for this event...
Definition: forwarderPort.h:513
DtForwarderPort::DtExecAddedCallbackList
std::vector< std::pair< DtExecAddChangeCb, void * > > DtExecAddedCallbackList
Definition: forwarderPort.h:93
DtForwarderPort::DtSockMsgPair
std::pair< DtTcpMsgSocket *, DtForwarderMsg > DtSockMsgPair
Definition: forwarderPort.h:57
DtForwarderPort::DtFederateRemovedCallbackList
std::vector< std::pair< DtFederateRemovedCb, void * > > DtFederateRemovedCallbackList
Definition: forwarderPort.h:91
DtForwarderPort::myReconnectCompleteCbs
DtConnectionReconnectCompleteCallbackList myReconnectCompleteCbs
Definition: forwarderPort.h:339
DtForwarderPort::myOk
bool myOk
Definition: forwarderPort.h:331
DtForwarderPort
The DtForwarderPort is an Abstract Base Class which provides the interface to a collection of connect...
Definition: forwarderPort.h:35
DtForwarderPort::notWaitingForForwarderConnections
virtual void notWaitingForForwarderConnections()
Called when exiting from the waiting for forwarder connections state.
Definition: forwarderPort.h:859
DtRIDParameters
This class manages the RTI&#39;s start-up configuration using both MTL variables and functions.
Definition: RIDparams.h:87
DtForwarderPort::DtWaitingForFwsCallbackList
std::vector< std::pair< DtWaitingForFwsCb, void * > > DtWaitingForFwsCallbackList
Definition: forwarderPort.h:96
DtForwarderPort::federateJoined
virtual void federateJoined(const MAKRti::DtString &connName, const MAKRti::DtString &connType, const MAKRti::DtString &federationName, unsigned int connID, unsigned int fedHandle, const DtInetAddrAndPort &addr, const MAKRti::DtString &hostName, unsigned int processId, const MAKRti::DtString &processName, const MAKRti::DtString &commandArgs, DtHlaVersionId hlaVersion)
Called when the federate joins/resigns.
Definition: forwarderPort.h:640
DtForwarderPort::myParams
const DtRIDParameters * myParams
Definition: forwarderPort.h:328
DtForwarderPort::DtForwarderMsg::transport
MAKRti::DtTransportType transport
Definition: forwarderPort.h:48
DtForwarderPort::removeForwarderPortReadyCb
virtual void removeForwarderPortReadyCb(DtPortReadyCb callback, void *usr)
Register/Unregister callback for event - forwarder port becomes ready.
Definition: forwarderPort.h:597
DtForwarderPort::removeConnectionLostCb
virtual void removeConnectionLostCb(DtConnectionAddRemoveCb callback, void *usr)
Register/Unregister callback for addition/removal/change of connections.
Definition: forwarderPort.h:410
DtForwarderPort::myConnectionChangedCbs
DtConnectionChangeCallbackList myConnectionChangedCbs
Definition: forwarderPort.h:340
DtForwarderPort::addForwarderPortReadyCb
virtual void addForwarderPortReadyCb(DtPortReadyCb callback, void *usr)
Register/Unregister callback for event - forwarder port becomes ready.
Definition: forwarderPort.h:585
DtForwarderPort::reconnectComplete
int reconnectComplete(const MAKRti::DtString &connName, const MAKRti::DtString &hostName, unsigned int connID, const DtInetAddrAndPort &addr, bool wasSuccessful)
Call when connection is added/removed/changed Invokes callbacks registered for this event...
Definition: forwarderPort.h:445
DtForwarderPort::removeSocketQueueCb
virtual void removeSocketQueueCb(DtSocketQueueCb callback, void *usr)
Register/Unregister callback for event - socket queue status changes.
Definition: forwarderPort.h:560
DtHlaVersionId
DtHlaVersionId
Definition: rtiVersion.h:41
DtForwarderPort::addWaitingForForwarderConnectionsCb
virtual void addWaitingForForwarderConnectionsCb(DtWaitingForFwsCb callback, void *usr)
Register/Unregister callback for event - entrance/exit the &quot;waiting for forwarder connections&quot; state...
Definition: forwarderPort.h:799
DtForwarderPort::removeFederateJoinedCb
virtual void removeFederateJoinedCb(DtFederateAddedCb callback, void *usr)
Register/Unregister callback for event - federate join/resign.
Definition: forwarderPort.h:633
DtForwarderPort::removeExecConnectionEstablishedCb
virtual void removeExecConnectionEstablishedCb(DtExecAddChangeCb callback, void *usr)
Register/Unregister callback for event - exec connected/disconnected.
Definition: forwarderPort.h:718
DtForwarderPort::DtExecRemovedCallbackList
std::vector< std::pair< DtExecRemovedChangeCb, void * > > DtExecRemovedCallbackList
Definition: forwarderPort.h:94
DtForwarderPort::addConnectionLostCb
virtual void addConnectionLostCb(DtConnectionAddRemoveCb callback, void *usr)
Register/Unregister callback for addition/removal/change of connections.
Definition: forwarderPort.h:398
DtForwarderPort::myPortToUse
int myPortToUse
Definition: forwarderPort.h:333
DtForwarderPort::myAddress
const MAKRti::DtInetAddr myAddress
Definition: forwarderPort.h:330
DtForwarderPort::isOk
virtual bool isOk() const
Is the Port still alive?
Definition: forwarderPort.h:110
DtForwarderPort::DtForwarderMsg
Definition: forwarderPort.h:44
DtForwarderPort::DtPortReadyCallbackList
std::vector< std::pair< DtPortReadyCb, void * > > DtPortReadyCallbackList
Definition: forwarderPort.h:92
DtForwarderPort::removeExecDisconnectedCb
virtual void removeExecDisconnectedCb(DtExecRemovedChangeCb callback, void *usr)
Register/Unregister callback for event - exec connected/disconnected.
Definition: forwarderPort.h:768
DtForwarderPort::addReconnectComplete
virtual void addReconnectComplete(DtConnectionReconnectCompleteCb callback, void *usr)
Register/Unregister callback for addition/removal/change of connections.
Definition: forwarderPort.h:495
DtForwarderPort::DtConnAndNameMap
std::map< DtInetAddrAndPort, MAKRti::DtString > DtConnAndNameMap
Definition: forwarderPort.h:59
DtForwarderPort::socketQueueStatus
virtual int socketQueueStatus(unsigned int connId, int connQueueStatus)
Called when the socket queue status changes.
Definition: forwarderPort.h:873
DtForwarderPort::myReconnectBegunCbs
DtConnectionReconnectBegunCallbackList myReconnectBegunCbs
Definition: forwarderPort.h:338
DtForwarderPort::mySocketQueueCbs
DtSocketQueueCallbackList mySocketQueueCbs
Definition: forwarderPort.h:346
DtForwarderPort::DtAddressMsgPair
std::pair< DtInetAddrAndPort, DtForwarderMsg > DtAddressMsgPair
Definition: forwarderPort.h:56
DtForwarderPort::connectionLost
virtual int connectionLost(const MAKRti::DtString &connName, const MAKRti::DtString &hostName, unsigned int connID, const std::pair< DtInetAddrAndPort, DtInetAddrAndPort > &addr)
Call when connection is added/removed/changed Invokes callbacks registered for this event...
Definition: forwarderPort.h:417
DtForwarderPort::removeReconnectBegun
virtual void removeReconnectBegun(DtConnectionReconnectBegunCb callback, void *usr)
Register/Unregister callback for addition/removal/change of connections.
Definition: forwarderPort.h:489
DtForwarderPort::DtSocketQueueCallbackList
std::vector< std::pair< DtSocketQueueCb, void * > > DtSocketQueueCallbackList
Definition: forwarderPort.h:95
DtForwarderPort::DtForwarderPort
DtForwarderPort(const DtRIDParameters *params, DtBoost::shared_ptr< DtRouteMap > routes, MAKRti::DtInetAddr host, int forwarderPort, MAKRti::DtInetEndpoint addnlConnection)
Definition: forwarderPort.h:100
DtForwarderPort::DtAddressPortList
DtRouteMap::DtAddressPortList DtAddressPortList
Definition: forwarderPort.h:51
DtForwarderPort::DtConnectionReconnectBegunCallbackList
std::vector< std::pair< DtConnectionReconnectBegunCb, void * > > DtConnectionReconnectBegunCallbackList
Definition: forwarderPort.h:87
DtForwarderPort::connectionEstablished
virtual int connectionEstablished(const MAKRti::DtString &connName, const MAKRti::DtString &hostName, unsigned int connID, const std::pair< DtInetAddrAndPort, DtInetAddrAndPort > &addr)
Call when connection is added/removed/changed Invokes callbacks registered for this event...
Definition: forwarderPort.h:383
DtForwarderPort::waitingForForwarderConnections
virtual void waitingForForwarderConnections(const DtConnAndNameMap &allNeededFws, const DtConnAndNameMap &stillNeededFws)
Specifies that this port is waiting for other forwarder connections.
Definition: forwarderPort.h:824
DtForwarderPort::myAdditionalAddrToConnectTo
MAKRti::DtInetEndpoint myAdditionalAddrToConnectTo
Definition: forwarderPort.h:334
DtRouteMap::DtAddressList
std::vector< MAKRti::DtInetAddr > DtAddressList
Definition: routeMap.h:60
DtRouteMap
Definition: routeMap.h:41
DtTcpMsgSocket
The DtTcpMsgSocket class provides an address family independent TCP socket that handles RTI messages...
Definition: tcpMsgSocket.h:42
DtForwarderPort::removeFederateResignedCb
virtual void removeFederateResignedCb(DtFederateRemovedCb callback, void *usr)
Register/Unregister callback for event - federate join/resign.
Definition: forwarderPort.h:541
DtForwarderPort::DtSocketList
std::vector< DtTcpMsgSocket * > DtSocketList
Definition: forwarderPort.h:54
DtForwarderPort::removeWaitingForForwarderConnectionsCb
virtual void removeWaitingForForwarderConnectionsCb(DtWaitingForFwsCb callback, void *usr)
Register/Unregister callback for event - entrance/exit the &quot;waiting for forwarder connections&quot; state...
Definition: forwarderPort.h:813
DtForwarderPort::execDisconnected
virtual int execDisconnected(const MAKRti::DtString &connName, unsigned int connID, const DtInetAddrAndPort &addr)
Called when the exec connects/disconnects.
Definition: forwarderPort.h:784
DtForwarderPort::myConnectionLostCbs
DtConnectionAddRemoveCallbackList myConnectionLostCbs
Definition: forwarderPort.h:337
DtForwarderPort::removeReconnectComplete
virtual void removeReconnectComplete(DtConnectionReconnectCompleteCb callback, void *usr)
Register/Unregister callback for addition/removal/change of connections.
Definition: forwarderPort.h:506
DtForwarderPort::addExecDisconnectedCb
virtual void addExecDisconnectedCb(DtExecRemovedChangeCb callback, void *usr)
Register/Unregister callback for event - exec connected/disconnected.
Definition: forwarderPort.h:756
DtForwarderPort::myExecDisconnectedCbs
DtExecRemovedCallbackList myExecDisconnectedCbs
Definition: forwarderPort.h:345
DtForwarderPort::DtForwarderMsg::length
int length
Definition: forwarderPort.h:47
DtForwarderPort::myPortReadyCbs
DtPortReadyCallbackList myPortReadyCbs
Definition: forwarderPort.h:343
DtForwarderPort::~DtForwarderPort
virtual ~DtForwarderPort()
Definition: forwarderPort.h:107
DtForwarderPort::DtConnectionAddRemoveCallbackList
std::vector< std::pair< DtConnectionAddRemoveCb, void * > > DtConnectionAddRemoveCallbackList
Definition: forwarderPort.h:86
DtForwarderPort::DtForwarderMsg::msg
caddr_t msg
Definition: forwarderPort.h:46
DtForwarderPort::DtFederateAddedCallbackList
std::vector< std::pair< DtFederateAddedCb, void * > > DtFederateAddedCallbackList
Definition: forwarderPort.h:90
DtForwarderPort::execConnected
virtual int execConnected(const MAKRti::DtString &connName, unsigned int connID, const DtInetAddrAndPort &addr, const MAKRti::DtString &hostName, bool fullyCompliant)
Called when the exec connects/disconnects.
Definition: forwarderPort.h:737
DtForwarderPort::forwarderNodeIsReady
virtual void forwarderNodeIsReady(unsigned long id)
Called when the forwarder port is known and node becomes ready.
Definition: forwarderPort.h:610
DtForwarderPort::myConnectionEstablishedCbs
DtConnectionAddRemoveCallbackList myConnectionEstablishedCbs
Definition: forwarderPort.h:336
DtForwarderPort::addFederateResignedCb
virtual void addFederateResignedCb(DtFederateRemovedCb callback, void *usr)
Register/Unregister callback for event - federate join/resign.
Definition: forwarderPort.h:529
DtForwarderPort::addNotWaitingForForwarderConnectionsCb
virtual void addNotWaitingForForwarderConnectionsCb(DtNotWaitingForFwsCb callback, void *usr)
Register/Unregister callback for event - entrance/exit the &quot;waiting for forwarder connections&quot; state...
Definition: forwarderPort.h:834
DtForwarderPort::addConnectionEstablishedCb
virtual void addConnectionEstablishedCb(DtConnectionAddRemoveCb callback, void *usr)
Register/Unregister callback for addition/removal/change of connections.
Definition: forwarderPort.h:363
DtForwarderPort::addConnectionChangedCb
virtual void addConnectionChangedCb(DtConnectionChangeCb callback, void *usr)
Register/Unregister callback for addition/removal/change of connections.
Definition: forwarderPort.h:459
DtRouteMap::DtInterfaceAddrSet
std::set< MAKRti::DtInetAddr > DtInterfaceAddrSet
Definition: routeMap.h:62
DtForwarderPort::myWaitingForFwsCbs
DtWaitingForFwsCallbackList myWaitingForFwsCbs
Definition: forwarderPort.h:347
DtForwarderPort::myNotWaitingForFwsCbs
DtNotWaitingForFwsCallbackList myNotWaitingForFwsCbs
Definition: forwarderPort.h:348
DtForwarderPort::DtAddrToConnMap
std::map< DtInetAddrAndPort, DtTcpMsgSocket * > DtAddrToConnMap
Definition: forwarderPort.h:58
DtForwarderPort::addExecConnectionEstablishedCb
virtual void addExecConnectionEstablishedCb(DtExecAddChangeCb callback, void *usr)
Register/Unregister callback for event - exec connected/disconnected.
Definition: forwarderPort.h:706
DtForwarderPort::removeConnectionEstablishedCb
virtual void removeConnectionEstablishedCb(DtConnectionAddRemoveCb callback, void *usr)
Register/Unregister callback for addition/removal/change of connections.
Definition: forwarderPort.h:375
DtForwarderPort::removeNotWaitingForForwarderConnectionsCb
virtual void removeNotWaitingForForwarderConnectionsCb(DtNotWaitingForFwsCb callback, void *usr)
Register/Unregister callback for event - entrance/exit the &quot;waiting for forwarder connections&quot; state...
Definition: forwarderPort.h:848
DT_DLL_FORWARDER
#define DT_DLL_FORWARDER
Definition: rtiMsConfig.h:124
DtForwarderPort::myFederateJoinedCbs
DtFederateAddedCallbackList myFederateJoinedCbs
Definition: forwarderPort.h:341
DtForwarderPort::addFederateJoinedCb
virtual void addFederateJoinedCb(DtFederateAddedCb callback, void *usr)
Register/Unregister callback for event - federate join/resign.
Definition: forwarderPort.h:621
DtForwarderPort::DtNotWaitingForFwsCallbackList
std::vector< std::pair< DtNotWaitingForFwsCb, void * > > DtNotWaitingForFwsCallbackList
Definition: forwarderPort.h:97
DtForwarderPort::reconnectBegun
int reconnectBegun(const MAKRti::DtString &connName, const MAKRti::DtString &hostName, unsigned int connID, const DtInetAddrAndPort &addr)
Call when connection is added/removed/changed Invokes callbacks registered for this event...
Definition: forwarderPort.h:431
DtForwarderPort::flush
virtual bool flush()
Flush any unsent/buffered packets; return true if flush sent data.
Definition: forwarderPort.h:351
DtForwarderPort::federateResigned
virtual void federateResigned(const MAKRti::DtString &connName, const MAKRti::DtString &connType, unsigned int connID, unsigned int fedHandle, const DtInetAddrAndPort &addr)
Called when the federate joins/resigns.
Definition: forwarderPort.h:569
DtForwarderPort::myFederateResignedCbs
DtFederateRemovedCallbackList myFederateResignedCbs
Definition: forwarderPort.h:342
DtRouteMap::DtAddressPortList
std::vector< DtInetAddrAndPort > DtAddressPortList
Definition: routeMap.h:59
DtForwarderPort::myRoutes
DtBoost::shared_ptr< DtRouteMap > myRoutes
Definition: forwarderPort.h:329
DtForwarderPort::DtConnectionReconnectCompleteCallbackList
std::vector< std::pair< DtConnectionReconnectCompleteCb, void * > > DtConnectionReconnectCompleteCallbackList
Definition: forwarderPort.h:88
DtForwarderPort::addReconnectBegun
virtual void addReconnectBegun(DtConnectionReconnectBegunCb callback, void *usr)
Register/Unregister callback for addition/removal/change of connections.
Definition: forwarderPort.h:478
Document ID: Generated on Mon Sep 7 15:40:32 EDT 2020 from SVN revision 217499
Copyright © 2005-2020 MAK Technologies Inc. All Rights Reserved (www.mak.com)