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 
16 #include <rtiMsConfig.h>
17 #include <rtiVersion.h>
18 #include <rtiMsg.h>
19 
20 #include <vlutil/vlConfig.h>
21 #include <vlutil/vlUtil.h>
22 #include <vlutil/vlSelectParamW.h>
23 #include <vlutil/vlFedTarget.h>
24 #include <vlutil/vlInetAddr.h>
25 #include <map>
26 #include <vector>
27 #include <algorithm>
28 #include <bitset>
29 
30 class DtRIDParameters;
31 class DtRouteMap;
32 class DtTcpMsgSocket;
33 
38 class DT_DLL_FORWARDER DtForwarderPort
39 {
40 public:
41 
43  typedef DtForwarderPort* (*DtForwarderPortCreatorFcn)( const DtRIDParameters*,
44  const std::shared_ptr<DtRouteMap>,
45  const MAKRti::DtInetAddr&, int, const MAKRti::DtInetEndpoint& );
46 
47  struct DtForwarderMsg
48  {
49  caddr_t msg;
50  int length;
51  MAKRti::DtTransportType transport;
52  };
53 
54  typedef DtRouteMap::DtAddressPortList DtAddressPortList;
55  typedef DtRouteMap::DtAddressList DtAddressList;
56  typedef DtRouteMap::DtInterfaceAddrSet DtInterfaceAddrSet;
57  typedef std::vector<DtTcpMsgSocket*> DtSocketList;
58  typedef std::set<DtTcpMsgSocket*> DtSocketSet;
59  typedef std::pair< DtInetAddrAndPort, DtForwarderMsg > DtAddressMsgPair;
60  typedef std::pair<DtTcpMsgSocket*, DtForwarderMsg> DtSockMsgPair;
61  typedef std::map< DtInetAddrAndPort, DtTcpMsgSocket* > DtAddrToConnMap;
62  typedef std::map<DtInetAddrAndPort, MAKRti::DtString> DtConnAndNameMap;
63 
64  typedef int (*DtConnectionAddRemoveCb)(const MAKRti::DtString&,
65  const MAKRti::DtString&, unsigned int, const std::pair<DtInetAddrAndPort, DtInetAddrAndPort>&, void*);
66  typedef int(*DtConnectionReconnectBegunCb)(const MAKRti::DtString&,
67  const MAKRti::DtString&, unsigned int, const DtInetAddrAndPort&, void*);
68  typedef int(*DtConnectionReconnectCompleteCb)(const MAKRti::DtString&,
69  const MAKRti::DtString&, unsigned int, const DtInetAddrAndPort&, bool, void*);
70  typedef int (*DtConnectionChangeCb)(const MAKRti::DtString& ,
71  const MAKRti::DtString&, unsigned int, unsigned int, const DtInetAddrAndPort&, void*);
72  typedef void (*DtFederateAddedCb)(const MAKRti::DtString&,
73  const MAKRti::DtString&, const MAKRti::DtString&, unsigned int,
74  unsigned int, const DtInetAddrAndPort&, const MAKRti::DtString&,
75  unsigned int, const MAKRti::DtString&, const MAKRti::DtString&,
76  DtHlaVersionId, void*);
77  typedef void (*DtFederateRemovedCb)(const MAKRti::DtString&,
78  const MAKRti::DtString&, unsigned int, unsigned int,
79  const DtInetAddrAndPort&, void*);
80  typedef void (*DtPortReadyCb)(unsigned long, void*);
81  typedef int (*DtExecAddChangeCb)(const MAKRti::DtString&, unsigned int,
82  const DtInetAddrAndPort&, const MAKRti::DtString&, bool, void*);
83  typedef int (*DtExecRemovedChangeCb)(const MAKRti::DtString&, unsigned int,
84  const DtInetAddrAndPort&, void*);
85  typedef int(*DtFederationShadowAddChangeCb)(unsigned int, unsigned int, const MAKRti::DtString&, void*);
86  typedef int(*DtFederationShadowRemovedChangeCb)(unsigned int, unsigned int, const MAKRti::DtString&, void*);
87  typedef int (*DtSocketQueueCb)(unsigned int, int, void*);
88  typedef void (*DtWaitingForFwsCb)(const DtConnAndNameMap&,
89  const DtConnAndNameMap&, void*);
90  typedef void (*DtNotWaitingForFwsCb)(void*);
91  typedef std::vector< std::pair< DtConnectionAddRemoveCb, void* > > DtConnectionAddRemoveCallbackList;
92  typedef std::vector< std::pair< DtConnectionReconnectBegunCb, void* > > DtConnectionReconnectBegunCallbackList;
93  typedef std::vector< std::pair< DtConnectionReconnectCompleteCb, void* > > DtConnectionReconnectCompleteCallbackList;
94  typedef std::vector< std::pair< DtConnectionChangeCb, void* > > DtConnectionChangeCallbackList;
95  typedef std::vector< std::pair< DtFederateAddedCb, void* > > DtFederateAddedCallbackList;
96  typedef std::vector< std::pair< DtFederateRemovedCb, void* > > DtFederateRemovedCallbackList;
97  typedef std::vector< std::pair< DtPortReadyCb, void*> > DtPortReadyCallbackList;
98  typedef std::vector< std::pair< DtExecAddChangeCb, void* > > DtExecAddedCallbackList;
99  typedef std::vector< std::pair< DtExecRemovedChangeCb, void* > > DtExecRemovedCallbackList;
100  typedef std::vector< std::pair< DtFederationShadowAddChangeCb, void* > > DtFederationShadowAddedCallbackList;
101  typedef std::vector< std::pair< DtFederationShadowRemovedChangeCb, void* > > DtFederationShadowRemovedCallbackList;
102  typedef std::vector< std::pair< DtSocketQueueCb, void* > > DtSocketQueueCallbackList;
103  typedef std::vector< std::pair< DtWaitingForFwsCb, void* > > DtWaitingForFwsCallbackList;
104  typedef std::vector< std::pair< DtNotWaitingForFwsCb, void* > > DtNotWaitingForFwsCallbackList;
105 
106 protected:
107  DtForwarderPort( const DtRIDParameters* params, std::shared_ptr<DtRouteMap> routes,
108  MAKRti::DtInetAddr host, int forwarderPort, MAKRti::DtInetEndpoint addnlConnection ) :
109  myParams( params ), myRoutes( routes ), myAddress( host ), myOk( true ),
110  myPortToUse(forwarderPort), myAdditionalAddrToConnectTo(addnlConnection)
111  {}
112 
113 public:
114  virtual ~DtForwarderPort() {};
115 
117  virtual bool isOk() const { return myOk; }
118 
120  virtual bool isReady() const = 0;
121 
123  virtual DtAddressMsgPair getNextMsg() = 0;
124 
126  virtual void sendByTransport( const DtForwarderMsg& msg ) const = 0;
127 
129  virtual void sendToAllReliable( const DtForwarderMsg& msg ) const = 0;
130 
133  virtual void sendToListReliable( const DtForwarderMsg& msg,
134  const DtRouteMap::DtAddressPortList& destinations ) const = 0;
135 
137  virtual inline bool flush();
138 
140  virtual void selectParams( MAKRti::DtSelectParamWithWrite& selectParams ) = 0;
141 
143  virtual void updateRoutes() = 0;
144 
147  virtual int checkConnectionStatus( const DtInetAddrAndPort* target = 0 ) = 0;
148 
150  virtual void clearNeededConnections() = 0;
151 
153  virtual unsigned int abortPendingConnections() = 0;
154 
156  virtual unsigned int pendingConnectionsAborted() = 0;
157 
159  virtual DtAddressPortList connections() const = 0;
160 
162 
163  virtual void listenToMulticastGroup( const MAKRti::DtInetAddr& mcastAddr ) = 0;
164  virtual void dropMulticastGroup( const MAKRti::DtInetAddr& mcastAddr ) = 0;
166 
168  virtual bool updateFederateConnectionId( unsigned long orig,
169  unsigned long final ) = 0;
170 
172 
173  virtual inline void addConnectionEstablishedCb( DtConnectionAddRemoveCb callback, void* usr );
174  virtual inline void removeConnectionEstablishedCb( DtConnectionAddRemoveCb callback, void* usr );
175  virtual inline void addConnectionLostCb( DtConnectionAddRemoveCb callback, void* usr );
176  virtual inline void removeConnectionLostCb( DtConnectionAddRemoveCb callback, void* usr );
177  virtual inline void addConnectionChangedCb( DtConnectionChangeCb callback, void* usr );
178  virtual inline void removeConnectionChangedCb( DtConnectionChangeCb callback, void* usr );
179 
180  virtual inline void addReconnectBegun(DtConnectionReconnectBegunCb callback, void* usr);
181  virtual inline void removeReconnectBegun(DtConnectionReconnectBegunCb callback, void* usr);
182  virtual inline void addReconnectComplete(DtConnectionReconnectCompleteCb callback, void* usr);
183  virtual inline void removeReconnectComplete(DtConnectionReconnectCompleteCb callback, void* usr);
185 
187 
188  virtual inline void addForwarderPortReadyCb( DtPortReadyCb callback, void* usr );
189  virtual inline void removeForwarderPortReadyCb( DtPortReadyCb callback, void* usr );
191 
193 
194  virtual inline void addFederateJoinedCb( DtFederateAddedCb callback, void* usr );
195  virtual inline void removeFederateJoinedCb( DtFederateAddedCb callback, void* usr );
196  virtual inline void addFederateResignedCb( DtFederateRemovedCb callback, void* usr );
197  virtual inline void removeFederateResignedCb( DtFederateRemovedCb callback, void* usr );
199 
201 
202  virtual inline void addSocketQueueCb( DtSocketQueueCb callback, void* usr );
203  virtual inline void removeSocketQueueCb( DtSocketQueueCb callback, void* usr );
205 
208 
209  virtual inline void addWaitingForForwarderConnectionsCb(DtWaitingForFwsCb callback, void* usr);
210  virtual inline void removeWaitingForForwarderConnectionsCb(DtWaitingForFwsCb callback, void* usr);
211  virtual inline void addNotWaitingForForwarderConnectionsCb(DtNotWaitingForFwsCb callback, void* usr);
212  virtual inline void removeNotWaitingForForwarderConnectionsCb(DtNotWaitingForFwsCb callback, void* usr);
214 
216 
217  virtual inline void addExecConnectionEstablishedCb(DtExecAddChangeCb callback, void* usr);
218  virtual inline void removeExecConnectionEstablishedCb(DtExecAddChangeCb callback, void * usr);
219  virtual inline void addExecDisconnectedCb(DtExecRemovedChangeCb callback, void* usr);
220  virtual inline void removeExecDisconnectedCb(DtExecRemovedChangeCb callback, void* usr);
222 
227  virtual void setForwarderId(unsigned long id);
228 
231 
232  virtual int execConnected( const MAKRti::DtString& connName,
233  unsigned int connID, const DtInetAddrAndPort& addr, const MAKRti::DtString& hostName,
234  bool fullyCompliant);
235  virtual int execDisconnected( const MAKRti::DtString& connName,
236  unsigned int connID, const DtInetAddrAndPort& addr );
238 
239  public:
240  static inline void printAddressMessage(const DtAddressMsgPair& addrMsg, MAKRti::DtOutputStream& outStream=MAKRti::DtVerbose);
241  static inline void printForwarderMessage(const DtForwarderMsg& frwdrMsg, MAKRti::DtOutputStream& outStream = MAKRti::DtVerbose);
242  static inline void printMessage(const caddr_t msg, MAKRti::DtOutputStream& outStream = MAKRti::DtVerbose);
243 
244 protected:
245 
248 
249  virtual inline int connectionEstablished( const MAKRti::DtString& connName,
250  const MAKRti::DtString& hostName, unsigned int connID, const std::pair<DtInetAddrAndPort, DtInetAddrAndPort>& addr);
251  virtual inline int connectionLost( const MAKRti::DtString& connName,
252  const MAKRti::DtString& hostName, unsigned int connID, const std::pair<DtInetAddrAndPort, DtInetAddrAndPort>& addr);
253  virtual inline int connectionChanged( const MAKRti::DtString& connName,
254  const MAKRti::DtString& hostName, unsigned int oldConnID, unsigned int newConnID, const DtInetAddrAndPort& addr );
255  inline int reconnectBegun(const MAKRti::DtString& connName,
256  const MAKRti::DtString& hostName, unsigned int connID, const DtInetAddrAndPort& addr);
257  inline int reconnectComplete(const MAKRti::DtString& connName,
258  const MAKRti::DtString& hostName, unsigned int connID, const DtInetAddrAndPort& addr, bool wasSuccessful);
260 
263  virtual void forwarderNodeIsReady(unsigned long id);
264 
267  virtual int socketQueueStatus( unsigned int connId, int connQueueStatus );
268 
273  virtual void waitingForForwarderConnections(const DtConnAndNameMap& allNeededFws,
274  const DtConnAndNameMap& stillNeededFws);
275 
278  virtual void notWaitingForForwarderConnections();
279 
282 
283  virtual void federateResigned( const MAKRti::DtString& connName,
284  const MAKRti::DtString& connType,unsigned int connID,
285  unsigned int fedHandle, const DtInetAddrAndPort& addr );
286  virtual void federateJoined( const MAKRti::DtString& connName,
287  const MAKRti::DtString& connType,
288  const MAKRti::DtString& federationName, unsigned int connID,
289  unsigned int fedHandle, const DtInetAddrAndPort& addr,
290  const MAKRti::DtString& hostName, unsigned int processId,
291  const MAKRti::DtString& processName,
292  const MAKRti::DtString& commandArgs, DtHlaVersionId hlaVersion );
294 
295 protected:
296 
298 
299  static int connectionEstablished( const MAKRti::DtString& connName,
300  const MAKRti::DtString& hostName, unsigned int connID, const std::pair<DtInetAddrAndPort, DtInetAddrAndPort>& addr, void* usr);
301  static int connectionLost( const MAKRti::DtString& connName,
302  const MAKRti::DtString& hostName, unsigned int connID, const std::pair<DtInetAddrAndPort, DtInetAddrAndPort>& addr, void* usr);
303  static int connectionChanged( const MAKRti::DtString& connName,
304  const MAKRti::DtString& hostName, unsigned int oldConnID, unsigned int newConnID,
305  const DtInetAddrAndPort& addr, void* usr );
307 
309 
310  static void federateJoined( const MAKRti::DtString& connName,
311  const MAKRti::DtString& connType,
312  const MAKRti::DtString& federationName, unsigned int connID,
313  unsigned int fedHandle, const DtInetAddrAndPort& addr,
314  const MAKRti::DtString& hostName, unsigned int processId,
315  const MAKRti::DtString& processName, const MAKRti::DtString& commandArgs,
316  DtHlaVersionId hlaVersion, void* usr);
317  static void federateResigned( const MAKRti::DtString& connName,
318  const MAKRti::DtString& connType,unsigned int connID,
319  unsigned int fedHandle, const DtInetAddrAndPort& addr, void* usr);
321 
323 
324  static int execConnected( const MAKRti::DtString& connName,
325  unsigned int connID, const DtInetAddrAndPort& addr,
326  const MAKRti::DtString& hostName, bool fullyCompliant, void* usr);
327  static int execDisconnected( const MAKRti::DtString& connName,
328  unsigned int connID, const DtInetAddrAndPort& addr, void* usr);
330 
332  static int socketQueueStatus( unsigned int connId, int connQueueStatus,
333  void* usr );
334 
336  static void forwarderNodeIsReady( unsigned long id, void* usr);
337 
338 protected:
339 
340  const DtRIDParameters* myParams;
341  std::shared_ptr<DtRouteMap> myRoutes;
342  const MAKRti::DtInetAddr myAddress;
343  bool myOk;
344 
345  int myPortToUse;
346  MAKRti::DtInetEndpoint myAdditionalAddrToConnectTo;
347 
348  DtConnectionAddRemoveCallbackList myConnectionEstablishedCbs;
349  DtConnectionAddRemoveCallbackList myConnectionLostCbs;
350  DtConnectionReconnectBegunCallbackList myReconnectBegunCbs;
351  DtConnectionReconnectCompleteCallbackList myReconnectCompleteCbs;
352  DtConnectionChangeCallbackList myConnectionChangedCbs;
353  DtFederateAddedCallbackList myFederateJoinedCbs;
354  DtFederateRemovedCallbackList myFederateResignedCbs;
355  DtPortReadyCallbackList myPortReadyCbs;
356  DtExecAddedCallbackList myExecConnectedCbs;
357  DtExecRemovedCallbackList myExecDisconnectedCbs;
358  DtSocketQueueCallbackList mySocketQueueCbs;
359  DtWaitingForFwsCallbackList myWaitingForFwsCbs;
360  DtNotWaitingForFwsCallbackList myNotWaitingForFwsCbs;
361 };
362 
363 inline bool DtForwarderPort::flush()
364 {
365  return false;
366 }
367 
368 
369 inline void DtForwarderPort::setForwarderId(unsigned long id)
370 {
371  // Do nothing.
372  return;
373 }
374 
375 inline void DtForwarderPort::addConnectionEstablishedCb( DtConnectionAddRemoveCb callback, void* usr )
376 {
378  std::pair<DtConnectionAddRemoveCb, void*> cbPair( callback, usr );
379  DtConnectionAddRemoveCallbackList::iterator pos = std::find( myConnectionEstablishedCbs.begin(),
380  myConnectionEstablishedCbs.end(), cbPair);
381  if ( pos == myConnectionEstablishedCbs.end() )
382  {
383  myConnectionEstablishedCbs.push_back( cbPair );
384  }
385 }
386 
387 inline void DtForwarderPort::removeConnectionEstablishedCb( DtConnectionAddRemoveCb callback, void* usr )
388 {
389  DtConnectionAddRemoveCallbackList::iterator pos = std::find( myConnectionEstablishedCbs.begin(),
390  myConnectionEstablishedCbs.end(), std::make_pair( callback, usr ));
391  if ( pos != myConnectionEstablishedCbs.end() ) myConnectionEstablishedCbs.erase( pos );
392 }
393 
394 
395 inline int DtForwarderPort::connectionEstablished( const MAKRti::DtString& connName,
396  const MAKRti::DtString& hostName, unsigned int connID, const std::pair<DtInetAddrAndPort, DtInetAddrAndPort>& addr)
397 {
398  int retVal = 0;
399  for ( DtConnectionAddRemoveCallbackList::iterator iter = myConnectionEstablishedCbs.begin();
400  iter != myConnectionEstablishedCbs.end(); ++iter )
401  {
402  if (-1 == ( *iter->first )( connName, hostName, connID, addr, iter->second ))
403  {
404  retVal = -1;
405  }
406  }
407  return retVal;
408 }
409 
410 inline void DtForwarderPort::addConnectionLostCb( DtConnectionAddRemoveCb callback, void* usr )
411 {
413  std::pair<DtConnectionAddRemoveCb, void*> cbPair( callback, usr );
414  DtConnectionAddRemoveCallbackList::iterator pos = std::find( myConnectionLostCbs.begin(),
415  myConnectionLostCbs.end(), cbPair);
416  if ( pos == myConnectionLostCbs.end() )
417  {
418  myConnectionLostCbs.push_back( cbPair );
419  }
420 }
421 
422 inline void DtForwarderPort::removeConnectionLostCb( DtConnectionAddRemoveCb callback, void* usr )
423 {
424  DtConnectionAddRemoveCallbackList::iterator pos = std::find( myConnectionLostCbs.begin(),
425  myConnectionLostCbs.end(), std::make_pair( callback, usr ));
426  if ( pos != myConnectionLostCbs.end() ) myConnectionLostCbs.erase( pos );
427 }
428 
429 inline int DtForwarderPort::connectionLost( const MAKRti::DtString& connName,
430  const MAKRti::DtString& hostName, unsigned int connID, const std::pair<DtInetAddrAndPort, DtInetAddrAndPort>& addr)
431 {
432  int retVal(0);
433  for ( DtConnectionAddRemoveCallbackList::iterator iter = myConnectionLostCbs.begin();
434  iter != myConnectionLostCbs.end(); ++iter )
435  {
436  if ( -1 == ( *iter->first )( connName, hostName, connID, addr, iter->second ) )
437  {
438  retVal = -1;
439  }
440  }
441  return retVal;
442 }
443 inline int DtForwarderPort::reconnectBegun(const MAKRti::DtString& connName,
444  const MAKRti::DtString& hostName, unsigned int connID, const DtInetAddrAndPort& addr)
445 {
446  int retVal(0);
447  for (DtConnectionReconnectBegunCallbackList::iterator iter = myReconnectBegunCbs.begin();
448  iter != myReconnectBegunCbs.end(); ++iter)
449  {
450  if (-1 == (*iter->first)(connName, hostName, connID, addr, iter->second))
451  {
452  retVal = -1;
453  }
454  }
455  return retVal;
456 }
457 inline int DtForwarderPort::reconnectComplete(const MAKRti::DtString& connName,
458  const MAKRti::DtString& hostName, unsigned int connID, const DtInetAddrAndPort& addr, bool wasSuccessful)
459 {
460  int retVal(0);
461  for (DtConnectionReconnectCompleteCallbackList::iterator iter = myReconnectCompleteCbs.begin();
462  iter != myReconnectCompleteCbs.end(); ++iter)
463  {
464  if (-1 == (*iter->first)(connName, hostName, connID, addr, wasSuccessful, iter->second))
465  {
466  retVal = -1;
467  }
468  }
469  return retVal;
470 }
471 inline void DtForwarderPort::addConnectionChangedCb( DtConnectionChangeCb callback, void* usr )
472 {
474  std::pair<DtConnectionChangeCb, void*> cbPair( callback, usr );
475  DtConnectionChangeCallbackList::iterator pos = std::find( myConnectionChangedCbs.begin(),
476  myConnectionChangedCbs.end(), cbPair);
477  if ( pos == myConnectionChangedCbs.end() )
478  {
479  myConnectionChangedCbs.push_back( cbPair );
480  }
481 }
482 
483 inline void DtForwarderPort::removeConnectionChangedCb( DtConnectionChangeCb callback, void* usr )
484 {
485  DtConnectionChangeCallbackList::iterator pos = std::find( myConnectionChangedCbs.begin(),
486  myConnectionChangedCbs.end(), std::make_pair( callback, usr ));
487  if ( pos != myConnectionChangedCbs.end() ) myConnectionChangedCbs.erase( pos );
488 }
489 
490 inline void DtForwarderPort::addReconnectBegun(DtConnectionReconnectBegunCb callback, void* usr)
491 {
493  std::pair<DtConnectionReconnectBegunCb, void*> cbPair(callback, usr);
494  DtConnectionReconnectBegunCallbackList::iterator pos = std::find(myReconnectBegunCbs.begin(),
495  myReconnectBegunCbs.end(), cbPair);
496  if (pos == myReconnectBegunCbs.end())
497  {
498  myReconnectBegunCbs.push_back(cbPair);
499  }
500 }
501 inline void DtForwarderPort::removeReconnectBegun(DtConnectionReconnectBegunCb callback, void* usr)
502 {
503  DtConnectionReconnectBegunCallbackList::iterator pos = std::find(myReconnectBegunCbs.begin(),
504  myReconnectBegunCbs.end(), std::make_pair(callback, usr));
505  if (pos != myReconnectBegunCbs.end()) myReconnectBegunCbs.erase(pos);
506 }
507 inline void DtForwarderPort::addReconnectComplete(DtConnectionReconnectCompleteCb callback, void* usr)
508 {
510  std::pair<DtConnectionReconnectCompleteCb, void*> cbPair(callback, usr);
511  DtConnectionReconnectCompleteCallbackList::iterator pos = std::find(myReconnectCompleteCbs.begin(),
512  myReconnectCompleteCbs.end(), cbPair);
513  if (pos == myReconnectCompleteCbs.end())
514  {
515  myReconnectCompleteCbs.push_back(cbPair);
516  }
517 }
518 inline void DtForwarderPort::removeReconnectComplete(DtConnectionReconnectCompleteCb callback, void* usr)
519 {
520  DtConnectionReconnectCompleteCallbackList::iterator pos = std::find(myReconnectCompleteCbs.begin(),
521  myReconnectCompleteCbs.end(), std::make_pair(callback, usr));
522  if (pos != myReconnectCompleteCbs.end()) myReconnectCompleteCbs.erase(pos);
523 }
524 
525 inline int DtForwarderPort::connectionChanged( const MAKRti::DtString& connName,
526  const MAKRti::DtString& hostName, unsigned int oldConnID, unsigned int newConnID,
527  const DtInetAddrAndPort& addr )
528 {
529  int retVal = 0;
530  for ( DtConnectionChangeCallbackList::iterator iter = myConnectionChangedCbs.begin();
531  iter != myConnectionChangedCbs.end(); ++iter )
532  {
533  if (-1 == ( *iter->first )( connName, hostName, oldConnID, newConnID, addr, iter->second ))
534  {
535  retVal = -1;
536  }
537  }
538  return retVal;
539 }
540 
541 inline void DtForwarderPort::addFederateResignedCb( DtFederateRemovedCb callback, void* usr )
542 {
544  std::pair<DtFederateRemovedCb, void*> cbPair( callback, usr );
545  DtFederateRemovedCallbackList::iterator pos = std::find( myFederateResignedCbs.begin(),
546  myFederateResignedCbs.end(), cbPair);
547  if ( pos == myFederateResignedCbs.end() )
548  {
549  myFederateResignedCbs.push_back( cbPair );
550  }
551 }
552 
553 inline void DtForwarderPort::removeFederateResignedCb( DtFederateRemovedCb callback, void* usr )
554 {
555  DtFederateRemovedCallbackList::iterator pos = std::find( myFederateResignedCbs.begin(),
556  myFederateResignedCbs.end(), std::make_pair( callback, usr ));
557  if ( pos != myFederateResignedCbs.end() ) myFederateResignedCbs.erase( pos );
558 }
559 
560 inline void DtForwarderPort::addSocketQueueCb( DtSocketQueueCb callback, void* usr )
561 {
563  std::pair< DtSocketQueueCb, void* > cbPair( callback, usr );
564 
565  DtSocketQueueCallbackList::iterator pos = std::find( mySocketQueueCbs.begin(),
566  mySocketQueueCbs.end(), cbPair );
567 
568  if( pos == mySocketQueueCbs.end() )
569  mySocketQueueCbs.push_back( cbPair );
570 }
571 
572 inline void DtForwarderPort::removeSocketQueueCb( DtSocketQueueCb callback, void* usr )
573 {
574  DtSocketQueueCallbackList::iterator pos = std::find( mySocketQueueCbs.begin(),
575  mySocketQueueCbs.end(), std::make_pair( callback, usr ));
576 
577  if( pos != mySocketQueueCbs.end() )
578  mySocketQueueCbs.erase( pos );
579 }
580 
581 inline void DtForwarderPort::federateResigned( const MAKRti::DtString& connName, const MAKRti::DtString& connType, unsigned int connID,
582  unsigned int fedHandle, const DtInetAddrAndPort& addr )
583 {
584  for ( DtFederateRemovedCallbackList::iterator iter = myFederateResignedCbs.begin();
585  iter != myFederateResignedCbs.end(); ++iter )
586  {
587  ( *iter->first )( connName, connType, connID, fedHandle, addr, iter->second );
588  }
589 }
590 
591 inline void DtForwarderPort::federateResigned(const MAKRti::DtString& connName, const MAKRti::DtString& connType, unsigned int connID,
592  unsigned int fedHandle, const DtInetAddrAndPort& addr, void* usr)
593 {
594  ((DtForwarderPort*)usr)->federateResigned(connName, connType, connID, fedHandle, addr);
595 }
596 
597 inline void DtForwarderPort::addForwarderPortReadyCb( DtPortReadyCb callback, void* usr )
598 {
600  std::pair<DtPortReadyCb, void*> cbPair( callback, usr );
601  DtPortReadyCallbackList::iterator pos = std::find( myPortReadyCbs.begin(),
602  myPortReadyCbs.end(), cbPair);
603  if ( pos == myPortReadyCbs.end() )
604  {
605  myPortReadyCbs.push_back( cbPair );
606  }
607 }
608 
609 inline void DtForwarderPort::removeForwarderPortReadyCb( DtPortReadyCb callback, void* usr )
610 {
611  DtPortReadyCallbackList::iterator pos = std::find( myPortReadyCbs.begin(),
612  myPortReadyCbs.end(), std::make_pair( callback, usr ));
613  if ( pos != myPortReadyCbs.end() ) myPortReadyCbs.erase( pos );
614 }
615 
616 
617 inline void DtForwarderPort::forwarderNodeIsReady(unsigned long id, void* usr)
618 {
619  return (static_cast<DtForwarderPort*>(usr))->forwarderNodeIsReady(id);
620 }
621 
622 inline void DtForwarderPort::forwarderNodeIsReady(unsigned long id)
623 {
624  for ( DtPortReadyCallbackList::iterator iter = myPortReadyCbs.begin();
625  iter != myPortReadyCbs.end(); ++iter )
626  {
627  ( *iter->first )( id, iter->second);
628  }
629 }
630 
631 
632 
633 inline void DtForwarderPort::addFederateJoinedCb( DtFederateAddedCb callback, void* usr )
634 {
636  std::pair<DtFederateAddedCb, void*> cbPair( callback, usr );
637  DtFederateAddedCallbackList::iterator pos = std::find( myFederateJoinedCbs.begin(),
638  myFederateJoinedCbs.end(), cbPair);
639  if ( pos == myFederateJoinedCbs.end() )
640  {
641  myFederateJoinedCbs.push_back( cbPair );
642  }
643 }
644 
645 inline void DtForwarderPort::removeFederateJoinedCb( DtFederateAddedCb callback, void* usr )
646 {
647  DtFederateAddedCallbackList::iterator pos = std::find( myFederateJoinedCbs.begin(),
648  myFederateJoinedCbs.end(), std::make_pair( callback, usr ));
649  if ( pos != myFederateJoinedCbs.end() ) myFederateJoinedCbs.erase( pos );
650 }
651 
652 inline void DtForwarderPort::federateJoined(const MAKRti::DtString& connName,
653  const MAKRti::DtString& connType,
654  const MAKRti::DtString& federationName,
655  unsigned int connID,
656  unsigned int fedHandle,
657  const DtInetAddrAndPort& addr,
658  const MAKRti::DtString& hostName,
659  unsigned int processId,
660  const MAKRti::DtString& processName,
661  const MAKRti::DtString& commandArgs,
662  DtHlaVersionId hlaVersion )
663 {
664  for ( DtFederateAddedCallbackList::iterator iter = myFederateJoinedCbs.begin();
665  iter != myFederateJoinedCbs.end(); ++iter )
666  {
667  ( *iter->first )( connName, connType, federationName, connID, fedHandle,
668  addr, hostName, processId, processName, commandArgs, hlaVersion,
669  iter->second );
670  }
671 }
672 
673 inline void DtForwarderPort::federateJoined(const MAKRti::DtString& connName,
674  const MAKRti::DtString& connType,
675  const MAKRti::DtString& federationName,
676  unsigned int connID,
677  unsigned int fedHandle,
678  const DtInetAddrAndPort& addr,
679  const MAKRti::DtString& hostName,
680  unsigned int processId,
681  const MAKRti::DtString& processName,
682  const MAKRti::DtString& commandArgs,
683  DtHlaVersionId hlaVersion,
684  void* usr)
685 {
686  ((DtForwarderPort*)usr)->federateJoined(connName, connType, federationName,
687  connID, fedHandle, addr, hostName, processId, processName, commandArgs,
688  hlaVersion);
689 }
690 
691 
692 inline int DtForwarderPort::connectionEstablished( const MAKRti::DtString& connName,
693  const MAKRti::DtString& hostName,
694  unsigned int connID,
695  const std::pair<DtInetAddrAndPort, DtInetAddrAndPort>& addr,
696  void* usr )
697 {
698  return ((DtForwarderPort*)usr)->connectionEstablished(connName, hostName, connID, addr);
699 }
700 
701 inline int DtForwarderPort::connectionLost( const MAKRti::DtString& connName,
702  const MAKRti::DtString& hostName,
703  unsigned int connID,
704  const std::pair<DtInetAddrAndPort, DtInetAddrAndPort>& addr,
705  void* usr )
706 {
707  return ((DtForwarderPort*)usr)->connectionLost(connName, hostName, connID, addr);
708 }
709 
710 inline int DtForwarderPort::connectionChanged( const MAKRti::DtString& connName,
711  const MAKRti::DtString& hostName, unsigned int oldConnID, unsigned int newConnID,
712  const DtInetAddrAndPort& addr,
713  void* usr )
714 {
715  return ((DtForwarderPort*)usr)->connectionChanged(connName, hostName, oldConnID, newConnID, addr);
716 }
717 
718 inline void DtForwarderPort::addExecConnectionEstablishedCb( DtExecAddChangeCb callback, void* usr )
719 {
721  std::pair<DtExecAddChangeCb, void*> cbPair( callback, usr );
722  DtExecAddedCallbackList::iterator pos = std::find( myExecConnectedCbs.begin(),
723  myExecConnectedCbs.end(), cbPair);
724  if ( pos == myExecConnectedCbs.end() )
725  {
726  myExecConnectedCbs.push_back( cbPair );
727  }
728 }
729 
730 inline void DtForwarderPort::removeExecConnectionEstablishedCb( DtExecAddChangeCb callback, void* usr )
731 {
732  DtExecAddedCallbackList::iterator pos = std::find( myExecConnectedCbs.begin(),
733  myExecConnectedCbs.end(), std::make_pair( callback, usr ));
734  if ( pos != myExecConnectedCbs.end() )
735  {
736  myExecConnectedCbs.erase( pos );
737  }
738 }
739 
740 inline int DtForwarderPort::execConnected( const MAKRti::DtString& connName,
741  unsigned int connID,
742  const DtInetAddrAndPort& addr,
743  const MAKRti::DtString& hostName,
744  bool fullyCompliant, void* usr)
745 {
746  return ((DtForwarderPort*)usr)->execConnected(connName, connID, addr, hostName, fullyCompliant);
747 }
748 
749 inline int DtForwarderPort::execConnected( const MAKRti::DtString& connName,
750  unsigned int connID,
751  const DtInetAddrAndPort& addr,
752  const MAKRti::DtString& hostName,
753  bool fullyCompliant )
754 {
755  int retVal = 0;
756  for ( DtExecAddedCallbackList::iterator iter = myExecConnectedCbs.begin();
757  iter != myExecConnectedCbs.end(); ++iter )
758  {
759  if ( -1 == ( *iter->first )( connName, connID, addr, hostName, fullyCompliant, iter->second ) )
760  {
761  retVal = -1;
762  }
763  }
764  return retVal;
765 }
766 
767 
768 inline void DtForwarderPort::addExecDisconnectedCb( DtExecRemovedChangeCb callback, void* usr )
769 {
771  std::pair<DtExecRemovedChangeCb, void*> cbPair( callback, usr );
772  DtExecRemovedCallbackList::iterator pos = std::find( myExecDisconnectedCbs.begin(),
773  myExecDisconnectedCbs.end(), cbPair);
774  if ( pos == myExecDisconnectedCbs.end() )
775  {
776  myExecDisconnectedCbs.push_back( cbPair );
777  }
778 }
779 
780 inline void DtForwarderPort::removeExecDisconnectedCb( DtExecRemovedChangeCb callback, void* usr )
781 {
782  DtExecRemovedCallbackList::iterator pos = std::find( myExecDisconnectedCbs.begin(),
783  myExecDisconnectedCbs.end(), std::make_pair( callback, usr ));
784  if ( pos != myExecDisconnectedCbs.end() )
785  {
786  myExecDisconnectedCbs.erase( pos );
787  }
788 }
789 
790 inline int DtForwarderPort::execDisconnected(const MAKRti::DtString& connName,
791  unsigned int connID, const DtInetAddrAndPort& addr, void* usr)
792 {
793  return ((DtForwarderPort*)usr)->execDisconnected(connName, connID, addr);
794 }
795 
796 inline int DtForwarderPort::execDisconnected( const MAKRti::DtString& connName,
797  unsigned int connID, const DtInetAddrAndPort& addr)
798 {
799  int retVal = 0;
800  for ( DtExecRemovedCallbackList::iterator iter = myExecDisconnectedCbs.begin();
801  iter != myExecDisconnectedCbs.end(); ++iter )
802  {
803  if ( -1 == ( *iter->first )( connName, connID, addr, iter->second ) )
804  {
805  retVal = -1;
806  }
807  }
808  return retVal;
809 }
810 
811 inline void DtForwarderPort::printAddressMessage(const DtForwarderPort::DtAddressMsgPair& addrMsg,
812  MAKRti::DtOutputStream& outStream/*=DtVerbose*/)
813 {
814  outStream << "Sender: " << addrMsg.first.first.toDtString() << ":" << addrMsg.first.second << " ";
815  printForwarderMessage(addrMsg.second);
816 }
817 
818 inline void DtForwarderPort::printForwarderMessage(const DtForwarderPort::DtForwarderMsg& frwdrMsg,
819  MAKRti::DtOutputStream& outStream/*=DtVerbose*/)
820 {
821  outStream << "Size: " << frwdrMsg.length << " Transport: " << (frwdrMsg.transport ? "Reliable " : "Best Effort ") << " ";
822  printMessage(frwdrMsg.msg);
823 }
824 
825 inline void DtForwarderPort::printMessage(const caddr_t msg, MAKRti::DtOutputStream& outStream/*=DtVerbose*/)
826 {
827  outStream << "Kind: " << DtRtiMsg::kindString(msg) << "(" << DtRtiMsg::msgKind(msg) << ")"
828  << " FedexHand: " << DtRtiMsg::fedExHandle(msg)
829  << " FedHand: " << DtRtiMsg::federateHandle(msg)
830  << " SeqNum: " << DtRtiMsg::sequenceNumber(msg)
831  << " Flags: " << std::bitset<8>(DtRtiMsg::flags(msg))
832  << " MetadataSize: " << DtRtiMsg::metadataSize(msg)
833  << std::endl;
834 }
835 
836 inline void DtForwarderPort::addWaitingForForwarderConnectionsCb(DtWaitingForFwsCb callback, void* usr)
837 {
839  std::pair< DtWaitingForFwsCb, void* > cbPair( callback, usr );
840 
841  DtWaitingForFwsCallbackList::iterator pos = std::find( myWaitingForFwsCbs.begin(),
842  myWaitingForFwsCbs.end(), cbPair );
843 
844  if( pos == myWaitingForFwsCbs.end() )
845  {
846  myWaitingForFwsCbs.push_back( cbPair );
847  }
848 }
849 
850 inline void DtForwarderPort::removeWaitingForForwarderConnectionsCb(DtWaitingForFwsCb callback, void* usr)
851 {
852  DtWaitingForFwsCallbackList::iterator pos = std::find( myWaitingForFwsCbs.begin(),
853  myWaitingForFwsCbs.end(), std::make_pair( callback, usr ));
854 
855  if( pos != myWaitingForFwsCbs.end() )
856  {
857  myWaitingForFwsCbs.erase( pos );
858  }
859 }
860 
861 inline void DtForwarderPort::waitingForForwarderConnections(const DtConnAndNameMap& allNeededFws,
862  const DtConnAndNameMap& stillNeededFws)
863 {
864  for ( DtWaitingForFwsCallbackList::iterator iter = myWaitingForFwsCbs.begin();
865  iter != myWaitingForFwsCbs.end(); ++iter )
866  {
867  ( *iter->first )( allNeededFws, stillNeededFws, iter->second );
868  }
869 }
870 
871 inline void DtForwarderPort::addNotWaitingForForwarderConnectionsCb(DtNotWaitingForFwsCb callback, void* usr)
872 {
874  std::pair< DtNotWaitingForFwsCb, void* > cbPair( callback, usr );
875 
876  DtNotWaitingForFwsCallbackList::iterator pos = std::find( myNotWaitingForFwsCbs.begin(),
877  myNotWaitingForFwsCbs.end(), cbPair );
878 
879  if( pos == myNotWaitingForFwsCbs.end() )
880  {
881  myNotWaitingForFwsCbs.push_back( cbPair );
882  }
883 }
884 
885 inline void DtForwarderPort::removeNotWaitingForForwarderConnectionsCb(DtNotWaitingForFwsCb callback, void* usr)
886 {
887  DtNotWaitingForFwsCallbackList::iterator pos = std::find( myNotWaitingForFwsCbs.begin(),
888  myNotWaitingForFwsCbs.end(), std::make_pair( callback, usr ));
889 
890  if( pos != myNotWaitingForFwsCbs.end() )
891  {
892  myNotWaitingForFwsCbs.erase( pos );
893  }
894 }
895 
896 inline void DtForwarderPort::notWaitingForForwarderConnections()
897 {
898  for ( DtNotWaitingForFwsCallbackList::iterator iter = myNotWaitingForFwsCbs.begin();
899  iter != myNotWaitingForFwsCbs.end(); ++iter )
900  {
901  ( *iter->first )( iter->second );
902  }
903 }
904 
905 inline int DtForwarderPort::socketQueueStatus( unsigned int connId, int connQueueStatus, void* usr )
906 {
907  return ((DtForwarderPort*)usr)->socketQueueStatus( connId, connQueueStatus );
908 }
909 
910 inline int DtForwarderPort::socketQueueStatus( unsigned int connId, int connQueueStatus )
911 {
912  int retVal = 0;
913 
914  for( DtSocketQueueCallbackList::iterator iter = mySocketQueueCbs.begin();
915  iter != mySocketQueueCbs.end(); ++iter )
916  {
917  if( -1 == ( *iter->first )( connId, connQueueStatus, iter->second ) )
918  {
919  retVal = -1;
920  }
921  }
922 
923  return retVal;
924 }
925 
926 
927 #endif
928 
929 
DtForwarderPort::DtInterfaceAddrSet
DtRouteMap::DtInterfaceAddrSet DtInterfaceAddrSet
Definition: forwarderPort.h:56
DtForwarderPort::DtSocketSet
std::set< DtTcpMsgSocket * > DtSocketSet
Definition: forwarderPort.h:58
DtForwarderPort::DtConnectionChangeCallbackList
std::vector< std::pair< DtConnectionChangeCb, void * > > DtConnectionChangeCallbackList
Definition: forwarderPort.h:94
DtRtiMsg::sequenceNumber
virtual unsigned long sequenceNumber() const
Set/Get message sequence number.
DtInetAddrAndPort
std::pair< MAKRti::DtInetAddr, int > DtInetAddrAndPort
Definition: rtiUtil.h:148
DtForwarderPort::DtAddressList
DtRouteMap::DtAddressList DtAddressList
Definition: forwarderPort.h:55
DtForwarderPort::myRoutes
std::shared_ptr< DtRouteMap > myRoutes
Definition: forwarderPort.h:341
DtForwarderPort::addSocketQueueCb
virtual void addSocketQueueCb(DtSocketQueueCb callback, void *usr)
Register/Unregister callback for event - socket queue status changes.
Definition: forwarderPort.h:560
DtForwarderPort::myExecConnectedCbs
DtExecAddedCallbackList myExecConnectedCbs
Definition: forwarderPort.h:356
DtForwarderPort::removeConnectionChangedCb
virtual void removeConnectionChangedCb(DtConnectionChangeCb callback, void *usr)
Register/Unregister callback for addition/removal/change of connections.
Definition: forwarderPort.h:483
DtForwarderPort::setForwarderId
virtual void setForwarderId(unsigned long id)
Set forwarder ID.
Definition: forwarderPort.h:369
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:525
DtForwarderPort::DtExecAddedCallbackList
std::vector< std::pair< DtExecAddChangeCb, void * > > DtExecAddedCallbackList
Definition: forwarderPort.h:98
DtForwarderPort::DtSockMsgPair
std::pair< DtTcpMsgSocket *, DtForwarderMsg > DtSockMsgPair
Definition: forwarderPort.h:60
DtForwarderPort::DtFederateRemovedCallbackList
std::vector< std::pair< DtFederateRemovedCb, void * > > DtFederateRemovedCallbackList
Definition: forwarderPort.h:96
DtForwarderPort::myReconnectCompleteCbs
DtConnectionReconnectCompleteCallbackList myReconnectCompleteCbs
Definition: forwarderPort.h:351
DtForwarderPort::myOk
bool myOk
Definition: forwarderPort.h:343
DtForwarderPort
The DtForwarderPort is an Abstract Base Class which provides the interface to a collection of connect...
Definition: forwarderPort.h:38
DtForwarderPort::notWaitingForForwarderConnections
virtual void notWaitingForForwarderConnections()
Called when exiting from the waiting for forwarder connections state.
Definition: forwarderPort.h:896
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:103
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:652
DtForwarderPort::myParams
const DtRIDParameters * myParams
Definition: forwarderPort.h:340
DtForwarderPort::DtForwarderMsg::transport
MAKRti::DtTransportType transport
Definition: forwarderPort.h:51
DtForwarderPort::removeForwarderPortReadyCb
virtual void removeForwarderPortReadyCb(DtPortReadyCb callback, void *usr)
Register/Unregister callback for event - forwarder port becomes ready.
Definition: forwarderPort.h:609
DtForwarderPort::removeConnectionLostCb
virtual void removeConnectionLostCb(DtConnectionAddRemoveCb callback, void *usr)
Register/Unregister callback for addition/removal/change of connections.
Definition: forwarderPort.h:422
DtForwarderPort::myConnectionChangedCbs
DtConnectionChangeCallbackList myConnectionChangedCbs
Definition: forwarderPort.h:352
DtForwarderPort::addForwarderPortReadyCb
virtual void addForwarderPortReadyCb(DtPortReadyCb callback, void *usr)
Register/Unregister callback for event - forwarder port becomes ready.
Definition: forwarderPort.h:597
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:457
DtForwarderPort::removeSocketQueueCb
virtual void removeSocketQueueCb(DtSocketQueueCb callback, void *usr)
Register/Unregister callback for event - socket queue status changes.
Definition: forwarderPort.h:572
DtHlaVersionId
DtHlaVersionId
Definition: rtiVersion.h:50
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:836
DtForwarderPort::printAddressMessage
static void printAddressMessage(const DtAddressMsgPair &addrMsg, MAKRti::DtOutputStream &outStream=MAKRti::DtVerbose)
Definition: forwarderPort.h:811
DtForwarderPort::removeFederateJoinedCb
virtual void removeFederateJoinedCb(DtFederateAddedCb callback, void *usr)
Register/Unregister callback for event - federate join/resign.
Definition: forwarderPort.h:645
DtForwarderPort::removeExecConnectionEstablishedCb
virtual void removeExecConnectionEstablishedCb(DtExecAddChangeCb callback, void *usr)
Register/Unregister callback for event - exec connected/disconnected.
Definition: forwarderPort.h:730
DtForwarderPort::DtExecRemovedCallbackList
std::vector< std::pair< DtExecRemovedChangeCb, void * > > DtExecRemovedCallbackList
Definition: forwarderPort.h:99
DtForwarderPort::addConnectionLostCb
virtual void addConnectionLostCb(DtConnectionAddRemoveCb callback, void *usr)
Register/Unregister callback for addition/removal/change of connections.
Definition: forwarderPort.h:410
DtForwarderPort::myPortToUse
int myPortToUse
Definition: forwarderPort.h:345
DtForwarderPort::myAddress
const MAKRti::DtInetAddr myAddress
Definition: forwarderPort.h:342
DtForwarderPort::isOk
virtual bool isOk() const
Is the Port still alive?
Definition: forwarderPort.h:117
DtForwarderPort::DtForwarderMsg
Definition: forwarderPort.h:47
DtForwarderPort::DtPortReadyCallbackList
std::vector< std::pair< DtPortReadyCb, void * > > DtPortReadyCallbackList
Definition: forwarderPort.h:97
DtForwarderPort::removeExecDisconnectedCb
virtual void removeExecDisconnectedCb(DtExecRemovedChangeCb callback, void *usr)
Register/Unregister callback for event - exec connected/disconnected.
Definition: forwarderPort.h:780
DtForwarderPort::DtFederationShadowRemovedCallbackList
std::vector< std::pair< DtFederationShadowRemovedChangeCb, void * > > DtFederationShadowRemovedCallbackList
Definition: forwarderPort.h:101
DtForwarderPort::addReconnectComplete
virtual void addReconnectComplete(DtConnectionReconnectCompleteCb callback, void *usr)
Register/Unregister callback for addition/removal/change of connections.
Definition: forwarderPort.h:507
DtForwarderPort::DtFederationShadowAddedCallbackList
std::vector< std::pair< DtFederationShadowAddChangeCb, void * > > DtFederationShadowAddedCallbackList
Definition: forwarderPort.h:100
DtForwarderPort::DtConnAndNameMap
std::map< DtInetAddrAndPort, MAKRti::DtString > DtConnAndNameMap
Definition: forwarderPort.h:62
DtForwarderPort::socketQueueStatus
virtual int socketQueueStatus(unsigned int connId, int connQueueStatus)
Called when the socket queue status changes.
Definition: forwarderPort.h:910
DtRtiMsg::metadataSize
static unsigned long metadataSize(const void *buffer)
Extracts the message metadata size form the given buffer.
DtForwarderPort::myReconnectBegunCbs
DtConnectionReconnectBegunCallbackList myReconnectBegunCbs
Definition: forwarderPort.h:350
DtForwarderPort::mySocketQueueCbs
DtSocketQueueCallbackList mySocketQueueCbs
Definition: forwarderPort.h:358
DtForwarderPort::DtAddressMsgPair
std::pair< DtInetAddrAndPort, DtForwarderMsg > DtAddressMsgPair
Definition: forwarderPort.h:59
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:429
DtForwarderPort::removeReconnectBegun
virtual void removeReconnectBegun(DtConnectionReconnectBegunCb callback, void *usr)
Register/Unregister callback for addition/removal/change of connections.
Definition: forwarderPort.h:501
DtForwarderPort::DtSocketQueueCallbackList
std::vector< std::pair< DtSocketQueueCb, void * > > DtSocketQueueCallbackList
Definition: forwarderPort.h:102
DtForwarderPort::DtAddressPortList
DtRouteMap::DtAddressPortList DtAddressPortList
Definition: forwarderPort.h:54
DtForwarderPort::DtConnectionReconnectBegunCallbackList
std::vector< std::pair< DtConnectionReconnectBegunCb, void * > > DtConnectionReconnectBegunCallbackList
Definition: forwarderPort.h:92
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:395
DtForwarderPort::waitingForForwarderConnections
virtual void waitingForForwarderConnections(const DtConnAndNameMap &allNeededFws, const DtConnAndNameMap &stillNeededFws)
Specifies that this port is waiting for other forwarder connections.
Definition: forwarderPort.h:861
DtForwarderPort::myAdditionalAddrToConnectTo
MAKRti::DtInetEndpoint myAdditionalAddrToConnectTo
Definition: forwarderPort.h:346
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:40
DtForwarderPort::removeFederateResignedCb
virtual void removeFederateResignedCb(DtFederateRemovedCb callback, void *usr)
Register/Unregister callback for event - federate join/resign.
Definition: forwarderPort.h:553
DtRtiMsg::msgKind
virtual DtRtiMsgKind msgKind() const
Get the message kind.
Definition: rtiMsg.h:305
DtForwarderPort::DtSocketList
std::vector< DtTcpMsgSocket * > DtSocketList
Definition: forwarderPort.h:57
DtForwarderPort::printForwarderMessage
static void printForwarderMessage(const DtForwarderMsg &frwdrMsg, MAKRti::DtOutputStream &outStream=MAKRti::DtVerbose)
Definition: forwarderPort.h:818
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:850
DtForwarderPort::execDisconnected
virtual int execDisconnected(const MAKRti::DtString &connName, unsigned int connID, const DtInetAddrAndPort &addr)
Called when the exec connects/disconnects.
Definition: forwarderPort.h:796
DtForwarderPort::myConnectionLostCbs
DtConnectionAddRemoveCallbackList myConnectionLostCbs
Definition: forwarderPort.h:349
DtForwarderPort::removeReconnectComplete
virtual void removeReconnectComplete(DtConnectionReconnectCompleteCb callback, void *usr)
Register/Unregister callback for addition/removal/change of connections.
Definition: forwarderPort.h:518
DtForwarderPort::addExecDisconnectedCb
virtual void addExecDisconnectedCb(DtExecRemovedChangeCb callback, void *usr)
Register/Unregister callback for event - exec connected/disconnected.
Definition: forwarderPort.h:768
DtForwarderPort::myExecDisconnectedCbs
DtExecRemovedCallbackList myExecDisconnectedCbs
Definition: forwarderPort.h:357
DtForwarderPort::DtForwarderMsg::length
int length
Definition: forwarderPort.h:50
DtForwarderPort::printMessage
static void printMessage(const caddr_t msg, MAKRti::DtOutputStream &outStream=MAKRti::DtVerbose)
Definition: forwarderPort.h:825
DtForwarderPort::myPortReadyCbs
DtPortReadyCallbackList myPortReadyCbs
Definition: forwarderPort.h:355
DtForwarderPort::~DtForwarderPort
virtual ~DtForwarderPort()
Definition: forwarderPort.h:114
DtForwarderPort::DtConnectionAddRemoveCallbackList
std::vector< std::pair< DtConnectionAddRemoveCb, void * > > DtConnectionAddRemoveCallbackList
Definition: forwarderPort.h:91
DtForwarderPort::DtForwarderMsg::msg
caddr_t msg
Definition: forwarderPort.h:49
DtForwarderPort::DtFederateAddedCallbackList
std::vector< std::pair< DtFederateAddedCb, void * > > DtFederateAddedCallbackList
Definition: forwarderPort.h:95
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:749
DtForwarderPort::forwarderNodeIsReady
virtual void forwarderNodeIsReady(unsigned long id)
Called when the forwarder port is known and node becomes ready.
Definition: forwarderPort.h:622
DtForwarderPort::myConnectionEstablishedCbs
DtConnectionAddRemoveCallbackList myConnectionEstablishedCbs
Definition: forwarderPort.h:348
DtForwarderPort::addFederateResignedCb
virtual void addFederateResignedCb(DtFederateRemovedCb callback, void *usr)
Register/Unregister callback for event - federate join/resign.
Definition: forwarderPort.h:541
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:871
DtForwarderPort::addConnectionEstablishedCb
virtual void addConnectionEstablishedCb(DtConnectionAddRemoveCb callback, void *usr)
Register/Unregister callback for addition/removal/change of connections.
Definition: forwarderPort.h:375
DtForwarderPort::addConnectionChangedCb
virtual void addConnectionChangedCb(DtConnectionChangeCb callback, void *usr)
Register/Unregister callback for addition/removal/change of connections.
Definition: forwarderPort.h:471
DtRouteMap::DtInterfaceAddrSet
std::set< MAKRti::DtInetAddr > DtInterfaceAddrSet
Definition: routeMap.h:62
DtForwarderPort::DtForwarderPort
DtForwarderPort(const DtRIDParameters *params, std::shared_ptr< DtRouteMap > routes, MAKRti::DtInetAddr host, int forwarderPort, MAKRti::DtInetEndpoint addnlConnection)
Definition: forwarderPort.h:107
DtForwarderPort::myWaitingForFwsCbs
DtWaitingForFwsCallbackList myWaitingForFwsCbs
Definition: forwarderPort.h:359
DtRtiMsg::kindString
virtual const char * kindString() const
Returns the message kind string name.
DtForwarderPort::myNotWaitingForFwsCbs
DtNotWaitingForFwsCallbackList myNotWaitingForFwsCbs
Definition: forwarderPort.h:360
DtForwarderPort::DtAddrToConnMap
std::map< DtInetAddrAndPort, DtTcpMsgSocket * > DtAddrToConnMap
Definition: forwarderPort.h:61
DtForwarderPort::addExecConnectionEstablishedCb
virtual void addExecConnectionEstablishedCb(DtExecAddChangeCb callback, void *usr)
Register/Unregister callback for event - exec connected/disconnected.
Definition: forwarderPort.h:718
DtForwarderPort::removeConnectionEstablishedCb
virtual void removeConnectionEstablishedCb(DtConnectionAddRemoveCb callback, void *usr)
Register/Unregister callback for addition/removal/change of connections.
Definition: forwarderPort.h:387
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:885
DT_DLL_FORWARDER
#define DT_DLL_FORWARDER
Definition: rtiMsConfig.h:153
DtForwarderPort::myFederateJoinedCbs
DtFederateAddedCallbackList myFederateJoinedCbs
Definition: forwarderPort.h:353
DtForwarderPort::addFederateJoinedCb
virtual void addFederateJoinedCb(DtFederateAddedCb callback, void *usr)
Register/Unregister callback for event - federate join/resign.
Definition: forwarderPort.h:633
DtForwarderPort::DtNotWaitingForFwsCallbackList
std::vector< std::pair< DtNotWaitingForFwsCb, void * > > DtNotWaitingForFwsCallbackList
Definition: forwarderPort.h:104
DtRtiMsg::flags
static unsigned char flags(const void *buffer)
Extracts the message flags form the given buffer.
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:443
DtForwarderPort::flush
virtual bool flush()
Flush any unsent/buffered packets; return true if flush sent data.
Definition: forwarderPort.h:363
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:581
DtForwarderPort::myFederateResignedCbs
DtFederateRemovedCallbackList myFederateResignedCbs
Definition: forwarderPort.h:354
DtRouteMap::DtAddressPortList
std::vector< DtInetAddrAndPort > DtAddressPortList
Definition: routeMap.h:59
DtRtiMsg::fedExHandle
virtual int fedExHandle() const
Get the federation execution identifier as a handle Returns 0 if the identifier is being represented ...
DtForwarderPort::DtConnectionReconnectCompleteCallbackList
std::vector< std::pair< DtConnectionReconnectCompleteCb, void * > > DtConnectionReconnectCompleteCallbackList
Definition: forwarderPort.h:93
DtForwarderPort::addReconnectBegun
virtual void addReconnectBegun(DtConnectionReconnectBegunCb callback, void *usr)
Register/Unregister callback for addition/removal/change of connections.
Definition: forwarderPort.h:490
DtRtiMsg::federateHandle
virtual DtFederateHandle federateHandle() const
Set/Get federate handle.
Definition: rtiMsg.h:315
Document ID: Generated on Sun Jul 20 16:15:30 EDT 2025 from SVN revision 277985
Copyright © 2005-2025 MAK Technologies Inc. All Rights Reserved (www.mak.com)