WebLVC 1.7d API Documentation
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
objectInterface.h
Go to the documentation of this file.
1 /****************************************************************************
2  * Copyright (c) 2014 VT MAK
3  * All rights reserved.
4  ****************************************************************************/
5 
9 
10 #if DtTENA
11 
12 #pragma once
13 
14 #include <vlTena/dllExport.h>
15 #include <vlTena/reflectedObject.h>
16 #include <vlTena/reflectedObjectList.h>
17 #include <vlTena/reflectedObjectCallbackInfo.h>
18 
19 #include <TENA/Middleware/SDO/ID.h>
20 #include <TENA/Time/Includes.h>
21 
22 #include <vlutil/vlMachineTypes.h>
23 
24 #include <list>
25 
26 class DtStateRepository;
27 
28 namespace MAKVrExchange
29 {
30 
31  namespace DtTenaBroker
32  {
33 
34  class DtExerciseConn;
35 
38  class DT_DLL_VLTENA DtTenaServantObject
39  {
40  public:
41 
43  DtTenaServantObject(){}
44 
46  virtual ~DtTenaServantObject(){}
47 
48  private:
49 
51  DtTenaServantObject( const DtTenaServantObject& other );
52 
54  DtTenaServantObject& operator = ( const DtTenaServantObject& other );
55 
56  };
57 
58 
63  class DT_DLL_VLTENA DtObjectInterface
64  {
65  public:
66 
68  DtObjectInterface(DtExerciseConn *conn);
69 
71  virtual ~DtObjectInterface();
72 
74  virtual DtTenaServantObject* createServantObject( DtExerciseConn* exConn ) = 0;
75 
77  virtual void processServantCleanup( DtTenaServantObject* servantObject ) = 0;
78 
80  virtual void subscribe() = 0;
81 
86  virtual bool needUpdate( const DtStateRepository& rep,
87  const DtStateRepository& asSeenBy, bool useThresholding = true ) = 0;
88 
91  virtual void decode( const DtTenaServantObject* servant,
92  DtStateRepository* stateRep ) const = 0;
93 
100  virtual void encode( DtTenaServantObject* servant, const DtStateRepository* stateRep,
101  TENA::Time::Pointer timeForStamping, bool forceUpdate = false ) = 0;
102 
104  virtual DtReflectedObject *createReflectedObject() const = 0;
105 
107  virtual void addObjectAdditionCallback( DtReflectedObjectCallbackFunction cb, void* userData);
108 
110  virtual void removeObjectAdditionCallback( DtReflectedObjectCallbackFunction cb, void* userData);
111 
113  virtual void addObjectRemovalCallback( DtReflectedObjectCallbackFunction cb, void* userData);
114 
116  virtual void removeObjectRemovalCallback( DtReflectedObjectCallbackFunction cb, void* userData);
117 
119  virtual void setReflectedObjectCreationFunction(DtCreateReflectedObjFn fn);
120 
122  virtual void setDiscoveryCondition(DtDiscoveryCondition fn, void* usr);
123 
125  virtual void clearDiscoveryCondition();
126 
130  void setUseTenaTimeForSets(bool yesNo);
131 
133  bool useTenaTimeForSets() const;
134 
135  protected:
136 
138  virtual void executeAdditionCallbacks(DtReflectedObject* refObject);
139 
141  virtual void executeRemovalCallbacks(DtReflectedObject* refObject);
142 
145  virtual void addPublishedObject(TENA::Middleware::SDO::ID sdoId);
146 
148  virtual void removePublishedObject(TENA::Middleware::SDO::ID);
149 
151  virtual bool isPublished(TENA::Middleware::SDO::ID sdoId) const;
152 
153  bool readyToAdd(DtReflectedObject* obj);
154 
155  protected:
156 
157  typedef std::list<DtReflectedObjectCallbackInfo> ReflectedObjectCallbackList;
158 
159  ReflectedObjectCallbackList myAdditionCallbackList;
160  ReflectedObjectCallbackList myRemovalCallbackList;
161  DtExerciseConn *myExConn;
162  DtCreateReflectedObjFn myCreateFunction;
163  std::set<TENA::Middleware::SDO::ID> myPublishedObjects;
164  DtDiscoveryCondition myDiscoveryCondition;
165  void* myDiscoveryConditionParameter;
166  bool myUseTenaTimeForSets;
167 
168  };
169 
170  }
171 }
172 
175 #define DtDEFINE_CALLBACKINFO(localName) \
176  \
177 class localName##CallbackInfo \
178 { \
179 public: \
180  localName##CallbackInfo(DtExerciseConn* exConn, localName##Interface* ptr): \
181  myExConn(exConn), \
182  myInterface(ptr) {} \
183  \
184  localName##Interface* interface() {return myInterface;}; \
185  DtExerciseConn* exConn() {return myExConn;} \
186 protected: \
187  DtExerciseConn* myExConn; \
188  localName##Interface* myInterface; \
189 }; \
190  \
191 typedef DCT::Utils::SmartPtr<localName##CallbackInfo> localName##CallbackInfoPtr;
192 
196 #define DtDEFINE_DISCOVERY_CALLBACK(localName, omNamespace) \
197 class localName##DiscoveryCallback : \
198  public virtual TENA::Middleware::Callback::Callback \
199 { \
200 public: \
201  localName##DiscoveryCallback( \
202  omNamespace::ProxyPtr const &proxy, \
203  localName##CallbackInfoPtr const & cbInfo ): \
204  myCbInfo(cbInfo), \
205  myProxy(proxy) { } \
206  \
207  virtual ~localName##DiscoveryCallback(){} \
208  \
209  void execute() \
210  { \
211  myCbInfo->interface()->processAddition(myProxy); \
212  myCbInfo->exConn()->incrementNumberOfMessagesProcessed(); \
213  } \
214  \
215 protected: \
216  localName##CallbackInfoPtr myCbInfo; \
217  omNamespace::ProxyPtr myProxy; \
218 };
219 
223 #define DtDEFINE_DISC_CALLBACK_FACTORY(localName, omNamespace) \
224 class localName##DiscoveryCallbackFactory : \
225  public virtual omNamespace::DiscoveryCallbackFactory \
226 { \
227 public: \
228  localName##DiscoveryCallbackFactory(localName##CallbackInfoPtr const & pc): \
229  myCallbackInfoPtr( pc ) {} \
230  \
231  virtual ~localName##DiscoveryCallbackFactory() {} \
232  \
233  std::auto_ptr< TENA::Middleware::Callback::Callback > create( \
234  omNamespace::ProxyPtr const & proxy) \
235  { \
236  return std::auto_ptr< TENA::Middleware::Callback::Callback >( \
237  new localName##DiscoveryCallback( proxy, myCallbackInfoPtr ) ); \
238  } \
239  \
240 protected: \
241  localName##CallbackInfoPtr myCallbackInfoPtr; \
242 };
243 
247 #define DtDEFINE_STATE_CHANGE_CALLBACK(localName, omNamespace) \
248 class localName##StateChangeCallback : \
249  public virtual TENA::Middleware::Callback::Callback \
250 { \
251 public: \
252  localName##StateChangeCallback( \
253  omNamespace::ProxyPtr const &proxy, \
254  localName##CallbackInfoPtr const & cbInfo ): \
255  myCbInfo(cbInfo), \
256  myProxy(proxy) { } \
257  \
258  virtual ~localName##StateChangeCallback(){} \
259  \
260  void execute() \
261  { \
262  myCbInfo->interface()->processUpdate(myProxy); \
263  myCbInfo->exConn()->incrementNumberOfMessagesProcessed(); \
264  } \
265  \
266 protected: \
267  localName##CallbackInfoPtr myCbInfo; \
268  omNamespace::ProxyPtr myProxy; \
269 };
270 
274 #define DtDEFINE_STATE_CHANGE_CALLBACK_FACTORY(localName, omNamespace) \
275 class localName##StateChangeCallbackFactory : \
276  public virtual omNamespace::StateChangeCallbackFactory \
277 { \
278 public: \
279  localName##StateChangeCallbackFactory( \
280  localName##CallbackInfoPtr const & pc): myCallbackInfoPtr( pc) { } \
281  \
282  virtual ~localName##StateChangeCallbackFactory() {} \
283  \
284  std::auto_ptr< TENA::Middleware::Callback::Callback > create( \
285  omNamespace::ProxyPtr const & proxy) \
286  { \
287  return std::auto_ptr< TENA::Middleware::Callback::Callback >( \
288  new localName##StateChangeCallback( proxy, myCallbackInfoPtr ) ); \
289  } \
290 protected: \
291  localName##CallbackInfoPtr myCallbackInfoPtr; \
292 };
293 
294 
298 #define DtDEFINE_DESTRUCTION_CALLBACK(localName, omNamespace) \
299 class localName##DestructionCallback : \
300  public virtual TENA::Middleware::Callback::Callback \
301 { \
302 public: \
303  localName##DestructionCallback( omNamespace::ProxyPtr const &proxy, \
304  localName##CallbackInfoPtr const & cbInfo ): \
305  myCbInfo(cbInfo), \
306  myProxy(proxy) { } \
307  \
308  virtual ~localName##DestructionCallback(){} \
309  \
310  void execute() \
311  { \
312  myCbInfo->interface()->processRemoval(myProxy); \
313  myCbInfo->exConn()->incrementNumberOfMessagesProcessed(); \
314  } \
315  \
316 protected: \
317  localName##CallbackInfoPtr myCbInfo; \
318  omNamespace::ProxyPtr myProxy; \
319 };
320 
324 #define DtDEFINE_DESTRUCTION_CALLBACK_FACTORY(localName, omNamespace) \
325 class localName##DestructionCallbackFactory : \
326  public virtual omNamespace::DestructionCallbackFactory \
327 { \
328 public: \
329  localName##DestructionCallbackFactory( \
330  localName##CallbackInfoPtr const & pc): \
331  myCallbackInfoPtr( pc ) {} \
332  \
333  virtual ~localName##DestructionCallbackFactory() {} \
334  \
335  std::auto_ptr< TENA::Middleware::Callback::Callback > create( \
336  omNamespace::ProxyPtr const & proxy) \
337  { \
338  return std::auto_ptr< TENA::Middleware::Callback::Callback >( \
339  new localName##DestructionCallback( proxy, myCallbackInfoPtr ) ); \
340  } \
341  \
342 protected: \
343  localName##CallbackInfoPtr myCallbackInfoPtr; \
344 };
345 
349 #define DtDEFINE_SUB_INFO_IMPL(localName, omNamespace) \
350 class localName##SubscriptionInfoImpl : public omNamespace::SubscriptionInfo \
351 { \
352 public: \
353  localName##SubscriptionInfoImpl(): \
354  omNamespace::SubscriptionInfo( \
355  omNamespace::DiscoveryCallbackFactoryPtr( \
356  new omNamespace::NullDiscoveryCallbackFactory), \
357  omNamespace::StateChangeCallbackFactoryPtr( \
358  new omNamespace::NullStateChangeCallbackFactory), \
359  omNamespace::DestructionCallbackFactoryPtr( \
360  new omNamespace::NullDestructionCallbackFactory)) \
361  { \
362  } \
363  \
364  localName##SubscriptionInfoImpl(localName##CallbackInfoPtr const &cbInfo): \
365  omNamespace::SubscriptionInfo( \
366  omNamespace::DiscoveryCallbackFactoryPtr( \
367  new localName##DiscoveryCallbackFactory(cbInfo)), \
368  omNamespace::StateChangeCallbackFactoryPtr( \
369  new localName##StateChangeCallbackFactory(cbInfo)), \
370  omNamespace::DestructionCallbackFactoryPtr( \
371  new localName##DestructionCallbackFactory(cbInfo))) \
372  { \
373  } \
374  \
375  virtual ~localName##SubscriptionInfoImpl() {} \
376 };
377 
382 #define DtDEFINE_SUB_INFO_IMPL_WITH_INHERITANCE(localName, omNamespace, inhOmNamespace) \
383 class localName##SubscriptionInfoImpl : public omNamespace::SubscriptionInfo \
384 { \
385 public: \
386  localName##SubscriptionInfoImpl(): \
387  omNamespace::SubscriptionInfo( \
388  omNamespace::DiscoveryCallbackFactoryPtr( \
389  new omNamespace::NullDiscoveryCallbackFactory), \
390  omNamespace::StateChangeCallbackFactoryPtr( \
391  new omNamespace::NullStateChangeCallbackFactory), \
392  omNamespace::DestructionCallbackFactoryPtr( \
393  new omNamespace::NullDestructionCallbackFactory), \
394  inhOmNamespace::SubscriptionInfoPtr()) \
395  { \
396  } \
397  \
398  localName##SubscriptionInfoImpl(localName##CallbackInfoPtr const &cbInfo): \
399  omNamespace::SubscriptionInfo( \
400  omNamespace::DiscoveryCallbackFactoryPtr( \
401  new localName##DiscoveryCallbackFactory(cbInfo)), \
402  omNamespace::StateChangeCallbackFactoryPtr( \
403  new localName##StateChangeCallbackFactory(cbInfo)), \
404  omNamespace::DestructionCallbackFactoryPtr( \
405  new localName##DestructionCallbackFactory(cbInfo)), \
406  inhOmNamespace::SubscriptionInfoPtr()) \
407  { \
408  } \
409  virtual ~localName##SubscriptionInfoImpl() {} \
410 };
411 
412 #endif // DtTENA
reflectedObjectList.h
Contains the DtReflectedObjectList class declaration.
DT_DLL_VLTENA
#define DT_DLL_VLTENA
Definition: brokers/tenaBroker/vlTena/dllExport.h:26
reflectedObjectCallbackInfo.h
Contains the DtReflectedObjectCallbackInfo class declaration.
Document ID: Generated on Wed Jun 21 15:05:44 EDT 2023 from SVN revision 256253
Copyright © 2005-2023 MAK Technologies. All Rights Reserved (www.mak.com)