IceStormInternal.cpp
Go to the documentation of this file.
1 // **********************************************************************
2 //
3 // Copyright (c) 2003-2017 ZeroC, Inc. All rights reserved.
4 //
5 // This copy of Ice is licensed to you under the terms described in the
6 // ICE_LICENSE file included in this distribution.
7 //
8 // **********************************************************************
9 //
10 // Ice version 3.7.0
11 //
12 // <auto-generated>
13 //
14 // Generated from file `IceStormInternal.ice'
15 //
16 // Warning: do not edit this file.
17 //
18 // </auto-generated>
19 //
20 
22 #include <IceUtil/PushDisableWarnings.h>
23 #include <Ice/LocalException.h>
24 #include <Ice/ValueFactory.h>
25 #include <Ice/OutgoingAsync.h>
26 #include <Ice/InputStream.h>
27 #include <Ice/OutputStream.h>
28 #include <Ice/LocalException.h>
29 #include <IceUtil/PopDisableWarnings.h>
30 
31 #if defined(_MSC_VER)
32 # pragma warning(disable:4458) // declaration of ... hides class member
33 #elif defined(__clang__)
34 # pragma clang diagnostic ignored "-Wshadow"
35 #elif defined(__GNUC__)
36 # pragma GCC diagnostic ignored "-Wshadow"
37 #endif
38 
39 #ifndef ICE_IGNORE_VERSION
40 # if ICE_INT_VERSION / 100 != 307
41 # error Ice version mismatch!
42 # endif
43 # if ICE_INT_VERSION % 100 > 50
44 # error Beta header file detected
45 # endif
46 # if ICE_INT_VERSION % 100 < 0
47 # error Ice patch level mismatch!
48 # endif
49 #endif
50 
51 #ifdef ICE_CPP11_MAPPING // C++11 mapping
52 
53 namespace
54 {
55 
56  const ::std::string iceC_IceStorm_TopicLink_ids[2] =
57  {
58  "::Ice::Object",
59  "::IceStorm::TopicLink"
60  };
61  const ::std::string iceC_IceStorm_TopicLink_ops[] =
62  {
63  "forward",
64  "ice_id",
65  "ice_ids",
66  "ice_isA",
67  "ice_ping"
68  };
69  const ::std::string iceC_IceStorm_TopicLink_forward_name = "forward";
70 
71  const ::IceInternal::DefaultUserExceptionFactoryInit<::IceStorm::ReapWouldBlock> iceC_IceStorm_ReapWouldBlock_init("::IceStorm::ReapWouldBlock");
72 
73  const ::std::string iceC_IceStorm_TopicInternal_ids[3] =
74  {
75  "::Ice::Object",
76  "::IceStorm::Topic",
77  "::IceStorm::TopicInternal"
78  };
79  const ::std::string iceC_IceStorm_TopicInternal_ops[] =
80  {
81  "destroy",
82  "getLinkInfoSeq",
83  "getLinkProxy",
84  "getName",
85  "getNonReplicatedPublisher",
86  "getPublisher",
87  "getSubscribers",
88  "ice_id",
89  "ice_ids",
90  "ice_isA",
91  "ice_ping",
92  "link",
93  "reap",
94  "subscribeAndGetPublisher",
95  "unlink",
96  "unsubscribe"
97  };
98  const ::std::string iceC_IceStorm_TopicInternal_getLinkProxy_name = "getLinkProxy";
99  const ::std::string iceC_IceStorm_TopicInternal_reap_name = "reap";
100 
101  const ::std::string iceC_IceStorm_TopicManagerInternal_ids[3] =
102  {
103  "::Ice::Object",
104  "::IceStorm::TopicManager",
105  "::IceStorm::TopicManagerInternal"
106  };
107  const ::std::string iceC_IceStorm_TopicManagerInternal_ops[] =
108  {
109  "create",
110  "getReplicaNode",
111  "getSliceChecksums",
112  "ice_id",
113  "ice_ids",
114  "ice_isA",
115  "ice_ping",
116  "retrieve",
117  "retrieveAll"
118  };
119  const ::std::string iceC_IceStorm_TopicManagerInternal_getReplicaNode_name = "getReplicaNode";
120 
121 }
122 
124 {
125 }
126 
127 const ::std::string&
128 IceStorm::SendQueueSizeMaxReached::ice_staticId()
129 {
130  static const ::std::string typeId = "::IceStorm::SendQueueSizeMaxReached";
131  return typeId;
132 }
133 
135 {
136 }
137 
138 const ::std::string&
139 IceStorm::ReapWouldBlock::ice_staticId()
140 {
141  static const ::std::string typeId = "::IceStorm::ReapWouldBlock";
142  return typeId;
143 }
144 
145 bool
146 IceStorm::TopicLink::ice_isA(::std::string s, const ::Ice::Current&) const
147 {
148  return ::std::binary_search(iceC_IceStorm_TopicLink_ids, iceC_IceStorm_TopicLink_ids + 2, s);
149 }
150 
151 ::std::vector<::std::string>
152 IceStorm::TopicLink::ice_ids(const ::Ice::Current&) const
153 {
154  return ::std::vector<::std::string>(&iceC_IceStorm_TopicLink_ids[0], &iceC_IceStorm_TopicLink_ids[2]);
155 }
156 
157 ::std::string
158 IceStorm::TopicLink::ice_id(const ::Ice::Current&) const
159 {
160  return ice_staticId();
161 }
162 
163 const ::std::string&
165 {
166  static const ::std::string typeId = "::IceStorm::TopicLink";
167  return typeId;
168 }
169 
170 bool
171 IceStorm::TopicLink::_iceD_forward(::IceInternal::Incoming& inS, const ::Ice::Current& current)
172 {
173  _iceCheckMode(::Ice::OperationMode::Normal, current.mode);
174  auto istr = inS.startReadParams();
175  ::IceStorm::EventDataSeq iceP_events;
176  istr->readAll(iceP_events);
177  inS.endReadParams();
178  this->forward(::std::move(iceP_events), current);
179  inS.writeEmptyParams();
180  return true;
181 }
182 
183 bool
184 IceStorm::TopicLink::_iceDispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
185 {
186  ::std::pair<const ::std::string*, const ::std::string*> r = ::std::equal_range(iceC_IceStorm_TopicLink_ops, iceC_IceStorm_TopicLink_ops + 5, current.operation);
187  if (r.first == r.second)
188  {
189  throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
190  }
191 
192  switch (r.first - iceC_IceStorm_TopicLink_ops)
193  {
194  case 0:
195  {
196  return _iceD_forward(in, current);
197  }
198  case 1:
199  {
200  return _iceD_ice_id(in, current);
201  }
202  case 2:
203  {
204  return _iceD_ice_ids(in, current);
205  }
206  case 3:
207  {
208  return _iceD_ice_isA(in, current);
209  }
210  case 4:
211  {
212  return _iceD_ice_ping(in, current);
213  }
214  default:
215  {
216  assert(false);
217  throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
218  }
219  }
220 }
221 
222 bool
223 IceStorm::TopicInternal::ice_isA(::std::string s, const ::Ice::Current&) const
224 {
225  return ::std::binary_search(iceC_IceStorm_TopicInternal_ids, iceC_IceStorm_TopicInternal_ids + 3, s);
226 }
227 
228 ::std::vector<::std::string>
229 IceStorm::TopicInternal::ice_ids(const ::Ice::Current&) const
230 {
231  return ::std::vector<::std::string>(&iceC_IceStorm_TopicInternal_ids[0], &iceC_IceStorm_TopicInternal_ids[3]);
232 }
233 
234 ::std::string
235 IceStorm::TopicInternal::ice_id(const ::Ice::Current&) const
236 {
237  return ice_staticId();
238 }
239 
240 const ::std::string&
242 {
243  static const ::std::string typeId = "::IceStorm::TopicInternal";
244  return typeId;
245 }
246 
247 bool
248 IceStorm::TopicInternal::_iceD_getLinkProxy(::IceInternal::Incoming& inS, const ::Ice::Current& current)
249 {
250  _iceCheckMode(::Ice::OperationMode::Idempotent, current.mode);
251  inS.readEmptyParams();
252  ::std::shared_ptr<::IceStorm::TopicLinkPrx> ret = this->getLinkProxy(current);
253  auto ostr = inS.startWriteParams();
254  ostr->writeAll(ret);
255  inS.endWriteParams();
256  return true;
257 }
258 
259 bool
260 IceStorm::TopicInternal::_iceD_reap(::IceInternal::Incoming& inS, const ::Ice::Current& current)
261 {
262  _iceCheckMode(::Ice::OperationMode::Normal, current.mode);
263  auto istr = inS.startReadParams();
264  ::Ice::IdentitySeq iceP_id;
265  istr->readAll(iceP_id);
266  inS.endReadParams();
267  this->reap(::std::move(iceP_id), current);
268  inS.writeEmptyParams();
269  return true;
270 }
271 
272 bool
273 IceStorm::TopicInternal::_iceDispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
274 {
275  ::std::pair<const ::std::string*, const ::std::string*> r = ::std::equal_range(iceC_IceStorm_TopicInternal_ops, iceC_IceStorm_TopicInternal_ops + 16, current.operation);
276  if (r.first == r.second)
277  {
278  throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
279  }
280 
281  switch (r.first - iceC_IceStorm_TopicInternal_ops)
282  {
283  case 0:
284  {
285  return _iceD_destroy(in, current);
286  }
287  case 1:
288  {
289  return _iceD_getLinkInfoSeq(in, current);
290  }
291  case 2:
292  {
293  return _iceD_getLinkProxy(in, current);
294  }
295  case 3:
296  {
297  return _iceD_getName(in, current);
298  }
299  case 4:
300  {
301  return _iceD_getNonReplicatedPublisher(in, current);
302  }
303  case 5:
304  {
305  return _iceD_getPublisher(in, current);
306  }
307  case 6:
308  {
309  return _iceD_getSubscribers(in, current);
310  }
311  case 7:
312  {
313  return _iceD_ice_id(in, current);
314  }
315  case 8:
316  {
317  return _iceD_ice_ids(in, current);
318  }
319  case 9:
320  {
321  return _iceD_ice_isA(in, current);
322  }
323  case 10:
324  {
325  return _iceD_ice_ping(in, current);
326  }
327  case 11:
328  {
329  return _iceD_link(in, current);
330  }
331  case 12:
332  {
333  return _iceD_reap(in, current);
334  }
335  case 13:
336  {
337  return _iceD_subscribeAndGetPublisher(in, current);
338  }
339  case 14:
340  {
341  return _iceD_unlink(in, current);
342  }
343  case 15:
344  {
345  return _iceD_unsubscribe(in, current);
346  }
347  default:
348  {
349  assert(false);
350  throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
351  }
352  }
353 }
354 
355 bool
356 IceStorm::TopicManagerInternal::ice_isA(::std::string s, const ::Ice::Current&) const
357 {
358  return ::std::binary_search(iceC_IceStorm_TopicManagerInternal_ids, iceC_IceStorm_TopicManagerInternal_ids + 3, s);
359 }
360 
361 ::std::vector<::std::string>
362 IceStorm::TopicManagerInternal::ice_ids(const ::Ice::Current&) const
363 {
364  return ::std::vector<::std::string>(&iceC_IceStorm_TopicManagerInternal_ids[0], &iceC_IceStorm_TopicManagerInternal_ids[3]);
365 }
366 
367 ::std::string
368 IceStorm::TopicManagerInternal::ice_id(const ::Ice::Current&) const
369 {
370  return ice_staticId();
371 }
372 
373 const ::std::string&
375 {
376  static const ::std::string typeId = "::IceStorm::TopicManagerInternal";
377  return typeId;
378 }
379 
380 bool
381 IceStorm::TopicManagerInternal::_iceD_getReplicaNode(::IceInternal::Incoming& inS, const ::Ice::Current& current) const
382 {
383  _iceCheckMode(::Ice::OperationMode::Idempotent, current.mode);
384  inS.readEmptyParams();
385  ::std::shared_ptr<::IceStormElection::NodePrx> ret = this->getReplicaNode(current);
386  auto ostr = inS.startWriteParams();
387  ostr->writeAll(ret);
388  inS.endWriteParams();
389  return true;
390 }
391 
392 bool
393 IceStorm::TopicManagerInternal::_iceDispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
394 {
395  ::std::pair<const ::std::string*, const ::std::string*> r = ::std::equal_range(iceC_IceStorm_TopicManagerInternal_ops, iceC_IceStorm_TopicManagerInternal_ops + 9, current.operation);
396  if (r.first == r.second)
397  {
398  throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
399  }
400 
401  switch (r.first - iceC_IceStorm_TopicManagerInternal_ops)
402  {
403  case 0:
404  {
405  return _iceD_create(in, current);
406  }
407  case 1:
408  {
409  return _iceD_getReplicaNode(in, current);
410  }
411  case 2:
412  {
413  return _iceD_getSliceChecksums(in, current);
414  }
415  case 3:
416  {
417  return _iceD_ice_id(in, current);
418  }
419  case 4:
420  {
421  return _iceD_ice_ids(in, current);
422  }
423  case 5:
424  {
425  return _iceD_ice_isA(in, current);
426  }
427  case 6:
428  {
429  return _iceD_ice_ping(in, current);
430  }
431  case 7:
432  {
433  return _iceD_retrieve(in, current);
434  }
435  case 8:
436  {
437  return _iceD_retrieveAll(in, current);
438  }
439  default:
440  {
441  assert(false);
442  throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
443  }
444  }
445 }
446 
447 void
448 IceStorm::TopicLinkPrx::_iceI_forward(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>& outAsync, const ::IceStorm::EventDataSeq& iceP_events, const ::Ice::Context& context)
449 {
450  outAsync->invoke(iceC_IceStorm_TopicLink_forward_name, ::Ice::OperationMode::Normal, ::Ice::FormatType::DefaultFormat, context,
451  [&](::Ice::OutputStream * ostr)
452  {
453  ostr->writeAll(iceP_events);
454  },
455  nullptr);
456 }
457 
458 ::std::shared_ptr<::Ice::ObjectPrx>
459 IceStorm::TopicLinkPrx::_newInstance() const
460 {
461  return ::IceInternal::createProxy<TopicLinkPrx>();
462 }
463 
464 const ::std::string&
465 IceStorm::TopicLinkPrx::ice_staticId()
466 {
468 }
469 
470 void
471 IceStorm::TopicInternalPrx::_iceI_getLinkProxy(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::std::shared_ptr<::IceStorm::TopicLinkPrx>>>& outAsync, const ::Ice::Context& context)
472 {
473  _checkTwowayOnly(iceC_IceStorm_TopicInternal_getLinkProxy_name);
474  outAsync->invoke(iceC_IceStorm_TopicInternal_getLinkProxy_name, ::Ice::OperationMode::Idempotent, ::Ice::FormatType::DefaultFormat, context,
475  nullptr,
476  nullptr);
477 }
478 
479 void
480 IceStorm::TopicInternalPrx::_iceI_reap(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>& outAsync, const ::Ice::IdentitySeq& iceP_id, const ::Ice::Context& context)
481 {
482  _checkTwowayOnly(iceC_IceStorm_TopicInternal_reap_name);
483  outAsync->invoke(iceC_IceStorm_TopicInternal_reap_name, ::Ice::OperationMode::Normal, ::Ice::FormatType::DefaultFormat, context,
484  [&](::Ice::OutputStream * ostr)
485  {
486  ostr->writeAll(iceP_id);
487  },
488  [](const ::Ice::UserException & ex)
489  {
490  try
491  {
492  ex.ice_throw();
493  }
494  catch (const ::IceStorm::ReapWouldBlock&)
495  {
496  throw;
497  }
498  catch (const ::Ice::UserException&)
499  {
500  }
501  });
502 }
503 
504 ::std::shared_ptr<::Ice::ObjectPrx>
505 IceStorm::TopicInternalPrx::_newInstance() const
506 {
507  return ::IceInternal::createProxy<TopicInternalPrx>();
508 }
509 
510 const ::std::string&
511 IceStorm::TopicInternalPrx::ice_staticId()
512 {
514 }
515 
516 void
517 IceStorm::TopicManagerInternalPrx::_iceI_getReplicaNode(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::std::shared_ptr<::IceStormElection::NodePrx>>>& outAsync, const ::Ice::Context& context)
518 {
519  _checkTwowayOnly(iceC_IceStorm_TopicManagerInternal_getReplicaNode_name);
520  outAsync->invoke(iceC_IceStorm_TopicManagerInternal_getReplicaNode_name, ::Ice::OperationMode::Idempotent, ::Ice::FormatType::DefaultFormat, context,
521  nullptr,
522  nullptr);
523 }
524 
525 ::std::shared_ptr<::Ice::ObjectPrx>
526 IceStorm::TopicManagerInternalPrx::_newInstance() const
527 {
528  return ::IceInternal::createProxy<TopicManagerInternalPrx>();
529 }
530 
531 const ::std::string&
532 IceStorm::TopicManagerInternalPrx::ice_staticId()
533 {
535 }
536 
537 namespace Ice
538 {
539 }
540 
541 #else // C++98 mapping
542 
543 namespace
544 {
545 
546  const ::std::string iceC_IceStorm_TopicLink_forward_name = "forward";
547 
548  const ::std::string iceC_IceStorm_TopicInternal_getLinkProxy_name = "getLinkProxy";
549 
550  const ::std::string iceC_IceStorm_TopicInternal_reap_name = "reap";
551 
552  const ::std::string iceC_IceStorm_TopicManagerInternal_getReplicaNode_name = "getReplicaNode";
553 
554 }
555 
557  ::Ice::LocalException(file_, line_)
558 {
559 }
560 
562 {
563 }
564 
565 ::std::string
567 {
568  return "::IceStorm::SendQueueSizeMaxReached";
569 }
570 
573 {
574  return new SendQueueSizeMaxReached(*this);
575 }
576 
577 void
579 {
580  throw* this;
581 }
582 
583 namespace
584 {
585 
586  const ::IceInternal::DefaultUserExceptionFactoryInit< ::IceStorm::ReapWouldBlock> iceC_IceStorm_ReapWouldBlock_init("::IceStorm::ReapWouldBlock");
587 
588 }
589 
591 {
592 }
593 
594 ::std::string
596 {
597  return "::IceStorm::ReapWouldBlock";
598 }
599 
602 {
603  return new ReapWouldBlock(*this);
604 }
605 
606 void
608 {
609  throw* this;
610 }
611 
612 void
613 IceStorm::ReapWouldBlock::_writeImpl(::Ice::OutputStream* ostr) const
614 {
615  ostr->startSlice("::IceStorm::ReapWouldBlock", -1, true);
617  ostr->endSlice();
618 }
619 
620 void
621 IceStorm::ReapWouldBlock::_readImpl(::Ice::InputStream* istr)
622 {
623  istr->startSlice();
625  istr->endSlice();
626 }
628 {
629  return p;
630 }
631 
632 void
634 {
635  ::Ice::ObjectPrx proxy;
636  istr->read(proxy);
637  if (!proxy)
638  {
639  v = 0;
640  }
641  else
642  {
643  v = new ::IceProxy::IceStorm::TopicLink;
644  v->_copyFrom(proxy);
645  }
646 }
647 
648 ::Ice::AsyncResultPtr
649 IceProxy::IceStorm::TopicLink::_iceI_begin_forward(const ::IceStorm::EventDataSeq& iceP_events, const ::Ice::Context& context, const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie, bool sync)
650 {
651  ::IceInternal::OutgoingAsyncPtr result = new ::IceInternal::CallbackOutgoing(this, iceC_IceStorm_TopicLink_forward_name, del, cookie, sync);
652  try
653  {
654  result->prepare(iceC_IceStorm_TopicLink_forward_name, ::Ice::Normal, context);
655  ::Ice::OutputStream* ostr = result->startWriteParams(::Ice::DefaultFormat);
656  ostr->write(iceP_events);
657  result->endWriteParams();
658  result->invoke(iceC_IceStorm_TopicLink_forward_name);
659  }
660  catch (const ::Ice::Exception& ex)
661  {
662  result->abort(ex);
663  }
664  return result;
665 }
666 
667 void
668 IceProxy::IceStorm::TopicLink::end_forward(const ::Ice::AsyncResultPtr& result)
669 {
670  _end(result, iceC_IceStorm_TopicLink_forward_name);
671 }
672 
673 ::IceProxy::Ice::Object*
675 {
676  return new TopicLink;
677 }
678 
679 const ::std::string&
681 {
682  return ::IceStorm::TopicLink::ice_staticId();
683 }
685 {
686  return p;
687 }
688 
689 void
691 {
692  ::Ice::ObjectPrx proxy;
693  istr->read(proxy);
694  if (!proxy)
695  {
696  v = 0;
697  }
698  else
699  {
700  v = new ::IceProxy::IceStorm::TopicInternal;
701  v->_copyFrom(proxy);
702  }
703 }
704 
705 ::Ice::AsyncResultPtr
706 IceProxy::IceStorm::TopicInternal::_iceI_begin_getLinkProxy(const ::Ice::Context& context, const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie, bool sync)
707 {
708  _checkTwowayOnly(iceC_IceStorm_TopicInternal_getLinkProxy_name, sync);
709  ::IceInternal::OutgoingAsyncPtr result = new ::IceInternal::CallbackOutgoing(this, iceC_IceStorm_TopicInternal_getLinkProxy_name, del, cookie, sync);
710  try
711  {
712  result->prepare(iceC_IceStorm_TopicInternal_getLinkProxy_name, ::Ice::Idempotent, context);
713  result->writeEmptyParams();
714  result->invoke(iceC_IceStorm_TopicInternal_getLinkProxy_name);
715  }
716  catch (const ::Ice::Exception& ex)
717  {
718  result->abort(ex);
719  }
720  return result;
721 }
722 
724 IceProxy::IceStorm::TopicInternal::end_getLinkProxy(const ::Ice::AsyncResultPtr& result)
725 {
726  ::Ice::AsyncResult::_check(result, this, iceC_IceStorm_TopicInternal_getLinkProxy_name);
728  if (!result->_waitForResponse())
729  {
730  try
731  {
732  result->_throwUserException();
733  }
734  catch (const ::Ice::UserException& ex)
735  {
736  throw ::Ice::UnknownUserException(__FILE__, __LINE__, ex.ice_id());
737  }
738  }
739  ::Ice::InputStream* istr = result->_startReadParams();
740  istr->read(ret);
741  result->_endReadParams();
742  return ret;
743 }
744 
745 ::Ice::AsyncResultPtr
746 IceProxy::IceStorm::TopicInternal::_iceI_begin_reap(const ::Ice::IdentitySeq& iceP_id, const ::Ice::Context& context, const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie, bool sync)
747 {
748  _checkTwowayOnly(iceC_IceStorm_TopicInternal_reap_name, sync);
749  ::IceInternal::OutgoingAsyncPtr result = new ::IceInternal::CallbackOutgoing(this, iceC_IceStorm_TopicInternal_reap_name, del, cookie, sync);
750  try
751  {
752  result->prepare(iceC_IceStorm_TopicInternal_reap_name, ::Ice::Normal, context);
753  ::Ice::OutputStream* ostr = result->startWriteParams(::Ice::DefaultFormat);
754  ostr->write(iceP_id);
755  result->endWriteParams();
756  result->invoke(iceC_IceStorm_TopicInternal_reap_name);
757  }
758  catch (const ::Ice::Exception& ex)
759  {
760  result->abort(ex);
761  }
762  return result;
763 }
764 
765 void
766 IceProxy::IceStorm::TopicInternal::end_reap(const ::Ice::AsyncResultPtr& result)
767 {
768  ::Ice::AsyncResult::_check(result, this, iceC_IceStorm_TopicInternal_reap_name);
769  if (!result->_waitForResponse())
770  {
771  try
772  {
773  result->_throwUserException();
774  }
775  catch (const ::IceStorm::ReapWouldBlock&)
776  {
777  throw;
778  }
779  catch (const ::Ice::UserException& ex)
780  {
781  throw ::Ice::UnknownUserException(__FILE__, __LINE__, ex.ice_id());
782  }
783  }
784  result->_readEmptyParams();
785 }
786 
787 ::IceProxy::Ice::Object*
789 {
790  return new TopicInternal;
791 }
792 
793 const ::std::string&
795 {
796  return ::IceStorm::TopicInternal::ice_staticId();
797 }
799 {
800  return p;
801 }
802 
803 void
805 {
806  ::Ice::ObjectPrx proxy;
807  istr->read(proxy);
808  if (!proxy)
809  {
810  v = 0;
811  }
812  else
813  {
814  v = new ::IceProxy::IceStorm::TopicManagerInternal;
815  v->_copyFrom(proxy);
816  }
817 }
818 
819 ::Ice::AsyncResultPtr
820 IceProxy::IceStorm::TopicManagerInternal::_iceI_begin_getReplicaNode(const ::Ice::Context& context, const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie, bool sync)
821 {
822  _checkTwowayOnly(iceC_IceStorm_TopicManagerInternal_getReplicaNode_name, sync);
823  ::IceInternal::OutgoingAsyncPtr result = new ::IceInternal::CallbackOutgoing(this, iceC_IceStorm_TopicManagerInternal_getReplicaNode_name, del, cookie, sync);
824  try
825  {
826  result->prepare(iceC_IceStorm_TopicManagerInternal_getReplicaNode_name, ::Ice::Idempotent, context);
827  result->writeEmptyParams();
828  result->invoke(iceC_IceStorm_TopicManagerInternal_getReplicaNode_name);
829  }
830  catch (const ::Ice::Exception& ex)
831  {
832  result->abort(ex);
833  }
834  return result;
835 }
836 
839 {
840  ::Ice::AsyncResult::_check(result, this, iceC_IceStorm_TopicManagerInternal_getReplicaNode_name);
842  if (!result->_waitForResponse())
843  {
844  try
845  {
846  result->_throwUserException();
847  }
848  catch (const ::Ice::UserException& ex)
849  {
850  throw ::Ice::UnknownUserException(__FILE__, __LINE__, ex.ice_id());
851  }
852  }
853  ::Ice::InputStream* istr = result->_startReadParams();
854  istr->read(ret);
855  result->_endReadParams();
856  return ret;
857 }
858 
859 ::IceProxy::Ice::Object*
861 {
862  return new TopicManagerInternal;
863 }
864 
865 const ::std::string&
867 {
868  return ::IceStorm::TopicManagerInternal::ice_staticId();
869 }
870 
872 {
873 }
874 
876 {
877  return p;
878 }
879 
880 
881 namespace
882 {
883  const ::std::string iceC_IceStorm_TopicLink_ids[2] =
884  {
885  "::Ice::Object",
886  "::IceStorm::TopicLink"
887  };
888 
889 }
890 
891 bool
892 IceStorm::TopicLink::ice_isA(const ::std::string& s, const ::Ice::Current&) const
893 {
894  return ::std::binary_search(iceC_IceStorm_TopicLink_ids, iceC_IceStorm_TopicLink_ids + 2, s);
895 }
896 
897 ::std::vector< ::std::string>
898 IceStorm::TopicLink::ice_ids(const ::Ice::Current&) const
899 {
900  return ::std::vector< ::std::string>(&iceC_IceStorm_TopicLink_ids[0], &iceC_IceStorm_TopicLink_ids[2]);
901 }
902 
903 const ::std::string&
904 IceStorm::TopicLink::ice_id(const ::Ice::Current&) const
905 {
906  return ice_staticId();
907 }
908 
909 const ::std::string&
911 {
912 #ifdef ICE_HAS_THREAD_SAFE_LOCAL_STATIC
913  static const ::std::string typeId = "::IceStorm::TopicLink";
914  return typeId;
915 #else
916  return iceC_IceStorm_TopicLink_ids[1];
917 #endif
918 }
919 
920 bool
921 IceStorm::TopicLink::_iceD_forward(::IceInternal::Incoming& inS, const ::Ice::Current& current)
922 {
923  _iceCheckMode(::Ice::Normal, current.mode);
924  ::Ice::InputStream* istr = inS.startReadParams();
925  ::IceStorm::EventDataSeq iceP_events;
926  istr->read(iceP_events);
927  inS.endReadParams();
928  this->forward(iceP_events, current);
929  inS.writeEmptyParams();
930  return true;
931 }
932 
933 namespace
934 {
935  const ::std::string iceC_IceStorm_TopicLink_all[] =
936  {
937  "forward",
938  "ice_id",
939  "ice_ids",
940  "ice_isA",
941  "ice_ping"
942  };
943 
944 }
945 
946 bool
947 IceStorm::TopicLink::_iceDispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
948 {
949  ::std::pair<const ::std::string*, const ::std::string*> r = ::std::equal_range(iceC_IceStorm_TopicLink_all, iceC_IceStorm_TopicLink_all + 5, current.operation);
950  if (r.first == r.second)
951  {
952  throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
953  }
954 
955  switch (r.first - iceC_IceStorm_TopicLink_all)
956  {
957  case 0:
958  {
959  return _iceD_forward(in, current);
960  }
961  case 1:
962  {
963  return _iceD_ice_id(in, current);
964  }
965  case 2:
966  {
967  return _iceD_ice_ids(in, current);
968  }
969  case 3:
970  {
971  return _iceD_ice_isA(in, current);
972  }
973  case 4:
974  {
975  return _iceD_ice_ping(in, current);
976  }
977  default:
978  {
979  assert(false);
980  throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
981  }
982  }
983 }
984 
985 void
986 IceStorm::TopicLink::_iceWriteImpl(::Ice::OutputStream* ostr) const
987 {
988  ostr->startSlice(ice_staticId(), -1, true);
990  ostr->endSlice();
991 }
992 
993 void
994 IceStorm::TopicLink::_iceReadImpl(::Ice::InputStream* istr)
995 {
996  istr->startSlice();
998  istr->endSlice();
999 }
1000 
1001 void
1003 {
1004  handle = ::IceStorm::TopicLinkPtr::dynamicCast(v);
1005  if (v && !handle)
1006  {
1007  IceInternal::Ex::throwUOE(::IceStorm::TopicLink::ice_staticId(), v);
1008  }
1009 }
1010 
1012 {
1013 }
1014 
1016 {
1017  return p;
1018 }
1019 
1020 
1021 namespace
1022 {
1023  const ::std::string iceC_IceStorm_TopicInternal_ids[3] =
1024  {
1025  "::Ice::Object",
1026  "::IceStorm::Topic",
1027  "::IceStorm::TopicInternal"
1028  };
1029 
1030 }
1031 
1032 bool
1033 IceStorm::TopicInternal::ice_isA(const ::std::string& s, const ::Ice::Current&) const
1034 {
1035  return ::std::binary_search(iceC_IceStorm_TopicInternal_ids, iceC_IceStorm_TopicInternal_ids + 3, s);
1036 }
1037 
1038 ::std::vector< ::std::string>
1039 IceStorm::TopicInternal::ice_ids(const ::Ice::Current&) const
1040 {
1041  return ::std::vector< ::std::string>(&iceC_IceStorm_TopicInternal_ids[0], &iceC_IceStorm_TopicInternal_ids[3]);
1042 }
1043 
1044 const ::std::string&
1045 IceStorm::TopicInternal::ice_id(const ::Ice::Current&) const
1046 {
1047  return ice_staticId();
1048 }
1049 
1050 const ::std::string&
1052 {
1053 #ifdef ICE_HAS_THREAD_SAFE_LOCAL_STATIC
1054  static const ::std::string typeId = "::IceStorm::TopicInternal";
1055  return typeId;
1056 #else
1057  return iceC_IceStorm_TopicInternal_ids[2];
1058 #endif
1059 }
1060 
1061 bool
1062 IceStorm::TopicInternal::_iceD_getLinkProxy(::IceInternal::Incoming& inS, const ::Ice::Current& current)
1063 {
1064  _iceCheckMode(::Ice::Idempotent, current.mode);
1065  inS.readEmptyParams();
1066  ::IceStorm::TopicLinkPrx ret = this->getLinkProxy(current);
1067  ::Ice::OutputStream* ostr = inS.startWriteParams();
1068  ostr->write(ret);
1069  inS.endWriteParams();
1070  return true;
1071 }
1072 
1073 bool
1074 IceStorm::TopicInternal::_iceD_reap(::IceInternal::Incoming& inS, const ::Ice::Current& current)
1075 {
1076  _iceCheckMode(::Ice::Normal, current.mode);
1077  ::Ice::InputStream* istr = inS.startReadParams();
1078  ::Ice::IdentitySeq iceP_id;
1079  istr->read(iceP_id);
1080  inS.endReadParams();
1081  this->reap(iceP_id, current);
1082  inS.writeEmptyParams();
1083  return true;
1084 }
1085 
1086 namespace
1087 {
1088  const ::std::string iceC_IceStorm_TopicInternal_all[] =
1089  {
1090  "destroy",
1091  "getLinkInfoSeq",
1092  "getLinkProxy",
1093  "getName",
1094  "getNonReplicatedPublisher",
1095  "getPublisher",
1096  "getSubscribers",
1097  "ice_id",
1098  "ice_ids",
1099  "ice_isA",
1100  "ice_ping",
1101  "link",
1102  "reap",
1103  "subscribeAndGetPublisher",
1104  "unlink",
1105  "unsubscribe"
1106  };
1107 
1108 }
1109 
1110 bool
1111 IceStorm::TopicInternal::_iceDispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
1112 {
1113  ::std::pair<const ::std::string*, const ::std::string*> r = ::std::equal_range(iceC_IceStorm_TopicInternal_all, iceC_IceStorm_TopicInternal_all + 16, current.operation);
1114  if (r.first == r.second)
1115  {
1116  throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
1117  }
1118 
1119  switch (r.first - iceC_IceStorm_TopicInternal_all)
1120  {
1121  case 0:
1122  {
1123  return _iceD_destroy(in, current);
1124  }
1125  case 1:
1126  {
1127  return _iceD_getLinkInfoSeq(in, current);
1128  }
1129  case 2:
1130  {
1131  return _iceD_getLinkProxy(in, current);
1132  }
1133  case 3:
1134  {
1135  return _iceD_getName(in, current);
1136  }
1137  case 4:
1138  {
1139  return _iceD_getNonReplicatedPublisher(in, current);
1140  }
1141  case 5:
1142  {
1143  return _iceD_getPublisher(in, current);
1144  }
1145  case 6:
1146  {
1147  return _iceD_getSubscribers(in, current);
1148  }
1149  case 7:
1150  {
1151  return _iceD_ice_id(in, current);
1152  }
1153  case 8:
1154  {
1155  return _iceD_ice_ids(in, current);
1156  }
1157  case 9:
1158  {
1159  return _iceD_ice_isA(in, current);
1160  }
1161  case 10:
1162  {
1163  return _iceD_ice_ping(in, current);
1164  }
1165  case 11:
1166  {
1167  return _iceD_link(in, current);
1168  }
1169  case 12:
1170  {
1171  return _iceD_reap(in, current);
1172  }
1173  case 13:
1174  {
1175  return _iceD_subscribeAndGetPublisher(in, current);
1176  }
1177  case 14:
1178  {
1179  return _iceD_unlink(in, current);
1180  }
1181  case 15:
1182  {
1183  return _iceD_unsubscribe(in, current);
1184  }
1185  default:
1186  {
1187  assert(false);
1188  throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
1189  }
1190  }
1191 }
1192 
1193 void
1194 IceStorm::TopicInternal::_iceWriteImpl(::Ice::OutputStream* ostr) const
1195 {
1196  ostr->startSlice(ice_staticId(), -1, true);
1198  ostr->endSlice();
1199 }
1200 
1201 void
1202 IceStorm::TopicInternal::_iceReadImpl(::Ice::InputStream* istr)
1203 {
1204  istr->startSlice();
1206  istr->endSlice();
1207 }
1208 
1209 void
1211 {
1212  handle = ::IceStorm::TopicInternalPtr::dynamicCast(v);
1213  if (v && !handle)
1214  {
1215  IceInternal::Ex::throwUOE(::IceStorm::TopicInternal::ice_staticId(), v);
1216  }
1217 }
1218 
1220 {
1221 }
1222 
1224 {
1225  return p;
1226 }
1227 
1228 
1229 namespace
1230 {
1231  const ::std::string iceC_IceStorm_TopicManagerInternal_ids[3] =
1232  {
1233  "::Ice::Object",
1234  "::IceStorm::TopicManager",
1235  "::IceStorm::TopicManagerInternal"
1236  };
1237 
1238 }
1239 
1240 bool
1241 IceStorm::TopicManagerInternal::ice_isA(const ::std::string& s, const ::Ice::Current&) const
1242 {
1243  return ::std::binary_search(iceC_IceStorm_TopicManagerInternal_ids, iceC_IceStorm_TopicManagerInternal_ids + 3, s);
1244 }
1245 
1246 ::std::vector< ::std::string>
1247 IceStorm::TopicManagerInternal::ice_ids(const ::Ice::Current&) const
1248 {
1249  return ::std::vector< ::std::string>(&iceC_IceStorm_TopicManagerInternal_ids[0], &iceC_IceStorm_TopicManagerInternal_ids[3]);
1250 }
1251 
1252 const ::std::string&
1253 IceStorm::TopicManagerInternal::ice_id(const ::Ice::Current&) const
1254 {
1255  return ice_staticId();
1256 }
1257 
1258 const ::std::string&
1260 {
1261 #ifdef ICE_HAS_THREAD_SAFE_LOCAL_STATIC
1262  static const ::std::string typeId = "::IceStorm::TopicManagerInternal";
1263  return typeId;
1264 #else
1265  return iceC_IceStorm_TopicManagerInternal_ids[2];
1266 #endif
1267 }
1268 
1269 bool
1270 IceStorm::TopicManagerInternal::_iceD_getReplicaNode(::IceInternal::Incoming& inS, const ::Ice::Current& current) const
1271 {
1272  _iceCheckMode(::Ice::Idempotent, current.mode);
1273  inS.readEmptyParams();
1274  ::IceStormElection::NodePrx ret = this->getReplicaNode(current);
1275  ::Ice::OutputStream* ostr = inS.startWriteParams();
1276  ostr->write(ret);
1277  inS.endWriteParams();
1278  return true;
1279 }
1280 
1281 namespace
1282 {
1283  const ::std::string iceC_IceStorm_TopicManagerInternal_all[] =
1284  {
1285  "create",
1286  "getReplicaNode",
1287  "getSliceChecksums",
1288  "ice_id",
1289  "ice_ids",
1290  "ice_isA",
1291  "ice_ping",
1292  "retrieve",
1293  "retrieveAll"
1294  };
1295 
1296 }
1297 
1298 bool
1299 IceStorm::TopicManagerInternal::_iceDispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
1300 {
1301  ::std::pair<const ::std::string*, const ::std::string*> r = ::std::equal_range(iceC_IceStorm_TopicManagerInternal_all, iceC_IceStorm_TopicManagerInternal_all + 9, current.operation);
1302  if (r.first == r.second)
1303  {
1304  throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
1305  }
1306 
1307  switch (r.first - iceC_IceStorm_TopicManagerInternal_all)
1308  {
1309  case 0:
1310  {
1311  return _iceD_create(in, current);
1312  }
1313  case 1:
1314  {
1315  return _iceD_getReplicaNode(in, current);
1316  }
1317  case 2:
1318  {
1319  return _iceD_getSliceChecksums(in, current);
1320  }
1321  case 3:
1322  {
1323  return _iceD_ice_id(in, current);
1324  }
1325  case 4:
1326  {
1327  return _iceD_ice_ids(in, current);
1328  }
1329  case 5:
1330  {
1331  return _iceD_ice_isA(in, current);
1332  }
1333  case 6:
1334  {
1335  return _iceD_ice_ping(in, current);
1336  }
1337  case 7:
1338  {
1339  return _iceD_retrieve(in, current);
1340  }
1341  case 8:
1342  {
1343  return _iceD_retrieveAll(in, current);
1344  }
1345  default:
1346  {
1347  assert(false);
1348  throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
1349  }
1350  }
1351 }
1352 
1353 void
1354 IceStorm::TopicManagerInternal::_iceWriteImpl(::Ice::OutputStream* ostr) const
1355 {
1356  ostr->startSlice(ice_staticId(), -1, true);
1358  ostr->endSlice();
1359 }
1360 
1361 void
1363 {
1364  istr->startSlice();
1366  istr->endSlice();
1367 }
1368 
1369 void
1371 {
1372  handle = ::IceStorm::TopicManagerInternalPtr::dynamicCast(v);
1373  if (v && !handle)
1374  {
1375  IceInternal::Ex::throwUOE(::IceStorm::TopicManagerInternal::ice_staticId(), v);
1376  }
1377 }
1378 
1379 namespace Ice
1380 {
1381 }
1382 
1383 #endif
IceStorm::upCast
::Ice::Object * upCast(::IceStorm::TopicLink *)
Definition: IceStormInternal.cpp:875
IceProxy::IceStorm::TopicInternal::end_reap
void end_reap(const ::Ice::AsyncResultPtr &)
Definition: IceStormInternal.cpp:766
IceStorm::ReapWouldBlock::_readImpl
virtual void _readImpl(::Ice::InputStream *)
Definition: IceStormInternal.cpp:621
IceStorm::SendQueueSizeMaxReached::ice_id
virtual ::std::string ice_id() const
Definition: IceStormInternal.cpp:566
armarx::aron::ret
ReaderT::InputType T & ret
Definition: rw.h:21
IceStorm::SendQueueSizeMaxReached::ice_clone
virtual SendQueueSizeMaxReached * ice_clone() const
Definition: IceStormInternal.cpp:572
IceProxy::IceStorm::TopicManagerInternal::_newInstance
virtual ::IceProxy::Ice::Object * _newInstance() const
Definition: IceStormInternal.cpp:860
IceStorm::ReapWouldBlock::ice_clone
virtual ReapWouldBlock * ice_clone() const
Definition: IceStormInternal.cpp:601
IceStorm::TopicInternal::ice_staticId
static const ::std::string & ice_staticId()
Definition: IceStormInternal.cpp:1051
IceProxy::IceStormElection::upCast
::IceProxy::Ice::Object * upCast(::IceProxy::IceStormElection::ReplicaObserver *)
Definition: Election.cpp:919
IceStorm::EventDataSeq
std::deque< ::IceStorm::EventDataPtr > EventDataSeq
A sequence of EventData.
Definition: IceStormInternal.h:463
IceStormInternal.h
IceProxy::IceStorm::TopicManagerInternal
Definition: IceStormInternal.h:642
IceStorm::TopicManagerInternal
Internal operations for a topic manager.
Definition: IceStormInternal.h:773
IceStorm::TopicInternal::ice_isA
virtual bool ice_isA(const ::std::string &, const ::Ice::Current &=::Ice::emptyCurrent) const
Definition: IceStormInternal.cpp:1033
IceStorm::TopicInternal::ice_id
virtual const ::std::string & ice_id(const ::Ice::Current &=::Ice::emptyCurrent) const
Definition: IceStormInternal.cpp:1045
IceStorm::ReapWouldBlock
Thrown if the reap call would block.
Definition: IceStormInternal.h:465
IceProxy::IceStorm::TopicManagerInternal::end_getReplicaNode
::IceStormElection::NodePrx end_getReplicaNode(const ::Ice::AsyncResultPtr &)
Definition: IceStormInternal.cpp:838
IceStorm::TopicInternal::_iceD_reap
bool _iceD_reap(::IceInternal::Incoming &, const ::Ice::Current &)
Definition: IceStormInternal.cpp:1074
IceStorm::TopicManagerInternal::ice_id
virtual const ::std::string & ice_id(const ::Ice::Current &=::Ice::emptyCurrent) const
Definition: IceStormInternal.cpp:1253
IceInternal::Handle
Definition: forward_declarations.h:8
IceStorm::TopicManagerInternal::~TopicManagerInternal
virtual ~TopicManagerInternal()
Definition: IceStormInternal.cpp:1219
IceStorm::TopicManagerInternal::_iceReadImpl
virtual void _iceReadImpl(::Ice::InputStream *)
Definition: IceStormInternal.cpp:1362
IceStorm::SendQueueSizeMaxReached::SendQueueSizeMaxReached
SendQueueSizeMaxReached(const char *, int)
Definition: IceStormInternal.cpp:556
IceStorm::TopicInternal
Internal operations for a topic.
Definition: IceStormInternal.h:734
IceProxy::IceStorm::TopicInternal::end_getLinkProxy
::IceStorm::TopicLinkPrx end_getLinkProxy(const ::Ice::AsyncResultPtr &)
Definition: IceStormInternal.cpp:724
IceStorm::ReapWouldBlock::_writeImpl
virtual void _writeImpl(::Ice::OutputStream *) const
Definition: IceStormInternal.cpp:613
IceStorm::ReapWouldBlock::ice_throw
virtual void ice_throw() const
Definition: IceStormInternal.cpp:607
IceStorm::TopicManagerInternal::ice_ids
virtual ::std::vector< ::std::string > ice_ids(const ::Ice::Current &=::Ice::emptyCurrent) const
Definition: IceStormInternal.cpp:1247
IceProxy::IceStormElection::_readProxy
void _readProxy(::Ice::InputStream *, ::IceInternal::ProxyHandle< ::IceProxy::IceStormElection::ReplicaObserver > &)
armarx::read
void read(auto &eigen, auto *table)
Definition: FTSensorCalibrationGuiWidgetController.cpp:462
IceStorm::SendQueueSizeMaxReached::~SendQueueSizeMaxReached
virtual ~SendQueueSizeMaxReached()
Definition: IceStormInternal.cpp:561
IceProxy::IceStorm::TopicManagerInternal::ice_staticId
static const ::std::string & ice_staticId()
Definition: IceStormInternal.cpp:866
IceStorm::TopicManagerInternal::ice_isA
virtual bool ice_isA(const ::std::string &, const ::Ice::Current &=::Ice::emptyCurrent) const
Definition: IceStormInternal.cpp:1241
IceStorm::TopicInternal::_iceReadImpl
virtual void _iceReadImpl(::Ice::InputStream *)
Definition: IceStormInternal.cpp:1202
IceStorm::ReapWouldBlock::~ReapWouldBlock
virtual ~ReapWouldBlock()
Definition: IceStormInternal.cpp:590
IceStorm::_icePatchObjectPtr
void _icePatchObjectPtr(TopicLinkPtr &, const ::Ice::ObjectPtr &)
Definition: IceStormInternal.cpp:1002
IceStorm::SendQueueSizeMaxReached
Definition: IceStormInternal.h:451
IceStorm::TopicManagerInternal::_iceWriteImpl
virtual void _iceWriteImpl(::Ice::OutputStream *) const
Definition: IceStormInternal.cpp:1354
IceStorm::TopicManagerInternal::_iceD_getReplicaNode
bool _iceD_getReplicaNode(::IceInternal::Incoming &, const ::Ice::Current &) const
Definition: IceStormInternal.cpp:1270
Ice
Definition: DBTypes.cpp:64
armarx::ctrlutil::v
double v(double t, double v0, double a0, double j)
Definition: CtrlUtil.h:39
IceProxy::IceStorm::TopicInternal::ice_staticId
static const ::std::string & ice_staticId()
Definition: IceStormInternal.cpp:794
IceStorm::TopicManagerInternal::ice_staticId
static const ::std::string & ice_staticId()
Definition: IceStormInternal.cpp:1259
IceInternal::ProxyHandle< ::IceProxy::IceStorm::TopicLink >
armarx::aron::write
requires data::isWriter< WriterT > void write(WriterT &aron_w, const Eigen::Matrix< EigenT, rows, cols, options > &input, typename WriterT::ReturnType &ret, const armarx::aron::Path &aron_p=armarx::aron::Path())
Definition: eigen.h:134
IceStorm::TopicManagerInternal::_iceDispatch
virtual bool _iceDispatch(::IceInternal::Incoming &, const ::Ice::Current &)
Definition: IceStormInternal.cpp:1299
armarx::aron::type::ObjectPtr
std::shared_ptr< Object > ObjectPtr
Definition: Object.h:36
IceStorm::TopicInternal::_iceWriteImpl
virtual void _iceWriteImpl(::Ice::OutputStream *) const
Definition: IceStormInternal.cpp:1194
IceStorm::TopicInternal::_iceD_getLinkProxy
bool _iceD_getLinkProxy(::IceInternal::Incoming &, const ::Ice::Current &)
Definition: IceStormInternal.cpp:1062
IceStorm::TopicInternal::~TopicInternal
virtual ~TopicInternal()
Definition: IceStormInternal.cpp:1011
IceStorm::ReapWouldBlock::ice_id
virtual ::std::string ice_id() const
Definition: IceStormInternal.cpp:595
armarx::ctrlutil::s
double s(double t, double s0, double v0, double a0, double j)
Definition: CtrlUtil.h:33
IceStorm::TopicInternal::ice_ids
virtual ::std::vector< ::std::string > ice_ids(const ::Ice::Current &=::Ice::emptyCurrent) const
Definition: IceStormInternal.cpp:1039
IceProxy::IceStorm::TopicInternal::_newInstance
virtual ::IceProxy::Ice::Object * _newInstance() const
Definition: IceStormInternal.cpp:788
IceProxy::IceStorm::TopicInternal
Definition: IceStormInternal.h:555
IceStorm::TopicInternal::_iceDispatch
virtual bool _iceDispatch(::IceInternal::Incoming &, const ::Ice::Current &)
Definition: IceStormInternal.cpp:1111
IceStorm::SendQueueSizeMaxReached::ice_throw
virtual void ice_throw() const
Definition: IceStormInternal.cpp:578