VR-Link API Documentation for HLA 1516
tObjectInterface.h
Go to the documentation of this file.
1 /*********************************************************************
2 ** Copyright (c) 1992-2010 VT MAK
3 ** All rights reserved.
4 *********************************************************************/
5 
6 
7 #ifndef tObjectInterface_H_
8 #define tObjectInterface_H_
9 
10 #if DtTENA
11 
12 #include <TENA/Time/Includes.h>
13 #include <TENA/Middleware/SDO/ID.h>
14 
15 #include <vlutil/vlMachineTypes.h>
16 #include "refObjCbInfo.h"
17 #include "tReflectedObj.h"
18 #include "tRefObjList.h"
19 #include <list>
20 
25 
26 class DT_DLL_VL DtExerciseConn;
27 class DT_DLL_VL DtStateRepository;
28 
29 
30 
33 class DT_DLL_VL DtTenaServantObject
34 {
35 
36 private:
38  DtTenaServantObject(const DtTenaServantObject& other);
39 
41  DtTenaServantObject& operator=(const DtTenaServantObject& other);
42 
43 public:
45  DtTenaServantObject(){}
46 
48  virtual ~DtTenaServantObject(){}
49 
50 };
51 
56 class DT_DLL_VL DtObjectInterface
57 {
58 public:
60  DtObjectInterface(DtExerciseConn *conn);
61 
63  virtual ~DtObjectInterface();
64 
66  virtual DtTenaServantObject* createServantObject(DtExerciseConn* exConn) =0;
67 
69  virtual void processServantCleanup(DtTenaServantObject* servantObject) =0;
70 
72  virtual void subscribe() = 0;
73 
78  virtual bool needUpdate(const DtStateRepository& rep, const DtStateRepository& asSeenBy,
79  bool useThresholding = true) = 0;
80 
83  virtual void decode(const DtTenaServantObject* servant, DtStateRepository* stateRep)const = 0;
84 
91  virtual void encode(DtTenaServantObject* servant, const DtStateRepository* stateRep,
92  TENA::Time::Pointer timeForStamping, bool forceUpdate = false) =0;
93 
95  virtual DtReflectedObject *createReflectedObject()const =0;
96 
98  virtual void addObjectAdditionCallback( DtReflectedObjectCallbackFunction cb, void* userData);
99 
101  virtual void removeObjectAdditionCallback( DtReflectedObjectCallbackFunction cb, void* userData);
102 
104  virtual void addObjectRemovalCallback( DtReflectedObjectCallbackFunction cb, void* userData);
105 
107  virtual void removeObjectRemovalCallback( DtReflectedObjectCallbackFunction cb, void* userData);
108 
110  virtual void setReflectedObjectCreationFunction(DtCreateReflectedObjFn fn);
111 
113  virtual void setDiscoveryCondition(DtDiscoveryCondition fn, void* usr);
114 
116  virtual void clearDiscoveryCondition();
117 
121  void setUseTenaTimeForSets(bool yesNo);
122 
124  bool useTenaTimeForSets() const;
125 
126 protected:
127 
129  virtual void executeAdditionCallbacks(DtReflectedObject* refObject);
130 
132  virtual void executeRemovalCallbacks(DtReflectedObject* refObject);
133 
136  virtual void addPublishedObject(TENA::Middleware::SDO::ID sdoId);
137 
139  virtual void removePublishedObject(TENA::Middleware::SDO::ID);
140 
142  virtual bool isPublished(TENA::Middleware::SDO::ID sdoId) const;
143 
144  bool readyToAdd(DtReflectedObject* obj);
145 
146 
147 protected:
148  typedef std::list<DtReflectedObjectCallbackInfo> ReflectedObjectCallbackList;
149 
150  ReflectedObjectCallbackList myAdditionCallbackList;
151  ReflectedObjectCallbackList myRemovalCallbackList;
152  DtExerciseConn *myExConn;
153  DtCreateReflectedObjFn myCreateFunction;
154  std::set<TENA::Middleware::SDO::ID> myPublishedObjects;
155  DtDiscoveryCondition myDiscoveryCondition;
156  void* myDiscoveryConditionParameter;
157  bool myUseTenaTimeForSets;
158 };
159 
162 #define DtDEFINE_CALLBACKINFO(localName) \
163  \
164 class localName##CallbackInfo \
165 { \
166 public: \
167  localName##CallbackInfo(DtExerciseConn* exConn, localName##Interface* ptr): \
168  myExConn(exConn), \
169  myInterface(ptr) {} \
170  \
171  localName##Interface* interface() {return myInterface;}; \
172  DtExerciseConn* exConn() {return myExConn;} \
173 protected: \
174  DtExerciseConn* myExConn; \
175  localName##Interface* myInterface; \
176 }; \
177  \
178 typedef DCT::Utils::SmartPtr<localName##CallbackInfo> localName##CallbackInfoPtr;
179 
183 #define DtDEFINE_DISCOVERY_CALLBACK(localName, omNamespace) \
184 class localName##DiscoveryCallback : \
185  public virtual TENA::Middleware::Callback::Callback \
186 { \
187 public: \
188  localName##DiscoveryCallback( \
189  omNamespace::ProxyPtr const &proxy, \
190  localName##CallbackInfoPtr const & cbInfo ): \
191  myCbInfo(cbInfo), \
192  myProxy(proxy) { } \
193  \
194  virtual ~localName##DiscoveryCallback(){} \
195  \
196  void execute() \
197  { \
198  myCbInfo->interface()->processAddition(myProxy); \
199  myCbInfo->exConn()->incrementNumberOfMessagesProcessed(); \
200  } \
201  \
202 protected: \
203  localName##CallbackInfoPtr myCbInfo; \
204  omNamespace::ProxyPtr myProxy; \
205 };
206 
210 #define DtDEFINE_DISC_CALLBACK_FACTORY(localName, omNamespace) \
211 class localName##DiscoveryCallbackFactory : \
212  public virtual omNamespace::DiscoveryCallbackFactory \
213 { \
214 public: \
215  localName##DiscoveryCallbackFactory(localName##CallbackInfoPtr const & pc): \
216  myCallbackInfoPtr( pc ) {} \
217  \
218  virtual ~localName##DiscoveryCallbackFactory() {} \
219  \
220  std::auto_ptr< TENA::Middleware::Callback::Callback > create( \
221  omNamespace::ProxyPtr const & proxy) \
222  { \
223  return std::auto_ptr< TENA::Middleware::Callback::Callback >( \
224  new localName##DiscoveryCallback( proxy, myCallbackInfoPtr ) ); \
225  } \
226  \
227 protected: \
228  localName##CallbackInfoPtr myCallbackInfoPtr; \
229 };
230 
234 #define DtDEFINE_STATE_CHANGE_CALLBACK(localName, omNamespace) \
235 class localName##StateChangeCallback : \
236  public virtual TENA::Middleware::Callback::Callback \
237 { \
238 public: \
239  localName##StateChangeCallback( \
240  omNamespace::ProxyPtr const &proxy, \
241  localName##CallbackInfoPtr const & cbInfo ): \
242  myCbInfo(cbInfo), \
243  myProxy(proxy) { } \
244  \
245  virtual ~localName##StateChangeCallback(){} \
246  \
247  void execute() \
248  { \
249  myCbInfo->interface()->processUpdate(myProxy); \
250  myCbInfo->exConn()->incrementNumberOfMessagesProcessed(); \
251  } \
252  \
253 protected: \
254  localName##CallbackInfoPtr myCbInfo; \
255  omNamespace::ProxyPtr myProxy; \
256 };
257 
261 #define DtDEFINE_STATE_CHANGE_CALLBACK_FACTORY(localName, omNamespace) \
262 class localName##StateChangeCallbackFactory : \
263  public virtual omNamespace::StateChangeCallbackFactory \
264 { \
265 public: \
266  localName##StateChangeCallbackFactory( \
267  localName##CallbackInfoPtr const & pc): myCallbackInfoPtr( pc) { } \
268  \
269  virtual ~localName##StateChangeCallbackFactory() {} \
270  \
271  std::auto_ptr< TENA::Middleware::Callback::Callback > create( \
272  omNamespace::ProxyPtr const & proxy) \
273  { \
274  return std::auto_ptr< TENA::Middleware::Callback::Callback >( \
275  new localName##StateChangeCallback( proxy, myCallbackInfoPtr ) ); \
276  } \
277 protected: \
278  localName##CallbackInfoPtr myCallbackInfoPtr; \
279 };
280 
281 
285 #define DtDEFINE_DESTRUCTION_CALLBACK(localName, omNamespace) \
286 class localName##DestructionCallback : \
287  public virtual TENA::Middleware::Callback::Callback \
288 { \
289 public: \
290  localName##DestructionCallback( omNamespace::ProxyPtr const &proxy, \
291  localName##CallbackInfoPtr const & cbInfo ): \
292  myCbInfo(cbInfo), \
293  myProxy(proxy) { } \
294  \
295  virtual ~localName##DestructionCallback(){} \
296  \
297  void execute() \
298  { \
299  myCbInfo->interface()->processRemoval(myProxy); \
300  myCbInfo->exConn()->incrementNumberOfMessagesProcessed(); \
301  } \
302  \
303 protected: \
304  localName##CallbackInfoPtr myCbInfo; \
305  omNamespace::ProxyPtr myProxy; \
306 };
307 
311 #define DtDEFINE_DESTRUCTION_CALLBACK_FACTORY(localName, omNamespace) \
312 class localName##DestructionCallbackFactory : \
313  public virtual omNamespace::DestructionCallbackFactory \
314 { \
315 public: \
316  localName##DestructionCallbackFactory( \
317  localName##CallbackInfoPtr const & pc): \
318  myCallbackInfoPtr( pc ) {} \
319  \
320  virtual ~localName##DestructionCallbackFactory() {} \
321  \
322  std::auto_ptr< TENA::Middleware::Callback::Callback > create( \
323  omNamespace::ProxyPtr const & proxy) \
324  { \
325  return std::auto_ptr< TENA::Middleware::Callback::Callback >( \
326  new localName##DestructionCallback( proxy, myCallbackInfoPtr ) ); \
327  } \
328  \
329 protected: \
330  localName##CallbackInfoPtr myCallbackInfoPtr; \
331 };
332 
336 #define DtDEFINE_SUB_INFO_IMPL(localName, omNamespace) \
337 class localName##SubscriptionInfoImpl : public omNamespace::SubscriptionInfo \
338 { \
339 public: \
340  localName##SubscriptionInfoImpl(): \
341  omNamespace::SubscriptionInfo( \
342  omNamespace::DiscoveryCallbackFactoryPtr( \
343  new omNamespace::NullDiscoveryCallbackFactory), \
344  omNamespace::StateChangeCallbackFactoryPtr( \
345  new omNamespace::NullStateChangeCallbackFactory), \
346  omNamespace::DestructionCallbackFactoryPtr( \
347  new omNamespace::NullDestructionCallbackFactory)) \
348  { \
349  } \
350  \
351  localName##SubscriptionInfoImpl(localName##CallbackInfoPtr const &cbInfo): \
352  omNamespace::SubscriptionInfo( \
353  omNamespace::DiscoveryCallbackFactoryPtr( \
354  new localName##DiscoveryCallbackFactory(cbInfo)), \
355  omNamespace::StateChangeCallbackFactoryPtr( \
356  new localName##StateChangeCallbackFactory(cbInfo)), \
357  omNamespace::DestructionCallbackFactoryPtr( \
358  new localName##DestructionCallbackFactory(cbInfo))) \
359  { \
360  } \
361  \
362  virtual ~localName##SubscriptionInfoImpl() {} \
363 };
364 
369 #define DtDEFINE_SUB_INFO_IMPL_WITH_INHERITANCE(localName, omNamespace, inhOmNamespace) \
370 class localName##SubscriptionInfoImpl : public omNamespace::SubscriptionInfo \
371 { \
372 public: \
373  localName##SubscriptionInfoImpl(): \
374  omNamespace::SubscriptionInfo( \
375  omNamespace::DiscoveryCallbackFactoryPtr( \
376  new omNamespace::NullDiscoveryCallbackFactory), \
377  omNamespace::StateChangeCallbackFactoryPtr( \
378  new omNamespace::NullStateChangeCallbackFactory), \
379  omNamespace::DestructionCallbackFactoryPtr( \
380  new omNamespace::NullDestructionCallbackFactory), \
381  inhOmNamespace::SubscriptionInfoPtr()) \
382  { \
383  } \
384  \
385  localName##SubscriptionInfoImpl(localName##CallbackInfoPtr const &cbInfo): \
386  omNamespace::SubscriptionInfo( \
387  omNamespace::DiscoveryCallbackFactoryPtr( \
388  new localName##DiscoveryCallbackFactory(cbInfo)), \
389  omNamespace::StateChangeCallbackFactoryPtr( \
390  new localName##StateChangeCallbackFactory(cbInfo)), \
391  omNamespace::DestructionCallbackFactoryPtr( \
392  new localName##DestructionCallbackFactory(cbInfo)), \
393  inhOmNamespace::SubscriptionInfoPtr()) \
394  { \
395  } \
396  virtual ~localName##SubscriptionInfoImpl() {} \
397 };
398 
399 
400 #endif
401 #endif
402 
Document ID: Generated on Wed Aug 14 15:35:11 EDT 2013 from SVN revision 130445
Copyright © 2005-2013 VT MÄK. All Rights Reserved (www.mak.com)