summaryrefslogtreecommitdiffstats
path: root/task1/ehr.h
diff options
context:
space:
mode:
Diffstat (limited to 'task1/ehr.h')
-rw-r--r--task1/ehr.h4594
1 files changed, 4594 insertions, 0 deletions
diff --git a/task1/ehr.h b/task1/ehr.h
new file mode 100644
index 0000000..7473373
--- /dev/null
+++ b/task1/ehr.h
@@ -0,0 +1,4594 @@
1// **********************************************************************
2//
3// Copyright (c) 2003-2009 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.3.1
11// Generated from file `ehr.ice'
12
13#ifndef __ehr_h__
14#define __ehr_h__
15
16#include <Ice/LocalObjectF.h>
17#include <Ice/ProxyF.h>
18#include <Ice/ObjectF.h>
19#include <Ice/Exception.h>
20#include <Ice/LocalObject.h>
21#include <Ice/Proxy.h>
22#include <Ice/Object.h>
23#include <Ice/Outgoing.h>
24#include <Ice/Incoming.h>
25#include <Ice/Direct.h>
26#include <Ice/UserExceptionFactory.h>
27#include <Ice/FactoryTable.h>
28#include <Ice/StreamF.h>
29#include <Ice/UndefSysMacros.h>
30
31#ifndef ICE_IGNORE_VERSION
32# if ICE_INT_VERSION / 100 != 303
33# error Ice version mismatch!
34# endif
35# if ICE_INT_VERSION % 100 > 50
36# error Beta header file detected
37# endif
38# if ICE_INT_VERSION % 100 < 1
39# error Ice patch level mismatch!
40# endif
41#endif
42
43namespace IceProxy
44{
45
46namespace Ehr
47{
48
49class Document;
50
51class Prescription;
52
53class ConsumedPrescription;
54
55class Request;
56
57class ThirdPartyRequest;
58
59class CreatePrescriptionRequest;
60
61class ConsumePrescriptionRequest;
62
63class ListDocumentsRequest;
64
65class FindDocumentsRequest;
66
67class CreatePermissionRequest;
68
69class SetDefaultAccessRequest;
70
71class ListPermissionsRequest;
72
73class RemovePermissionRequest;
74
75class Provider;
76
77}
78
79}
80
81namespace Ehr
82{
83
84class Document;
85bool operator==(const Document&, const Document&);
86bool operator<(const Document&, const Document&);
87
88class Prescription;
89bool operator==(const Prescription&, const Prescription&);
90bool operator<(const Prescription&, const Prescription&);
91
92class ConsumedPrescription;
93bool operator==(const ConsumedPrescription&, const ConsumedPrescription&);
94bool operator<(const ConsumedPrescription&, const ConsumedPrescription&);
95
96class Request;
97bool operator==(const Request&, const Request&);
98bool operator<(const Request&, const Request&);
99
100class ThirdPartyRequest;
101bool operator==(const ThirdPartyRequest&, const ThirdPartyRequest&);
102bool operator<(const ThirdPartyRequest&, const ThirdPartyRequest&);
103
104class CreatePrescriptionRequest;
105bool operator==(const CreatePrescriptionRequest&, const CreatePrescriptionRequest&);
106bool operator<(const CreatePrescriptionRequest&, const CreatePrescriptionRequest&);
107
108class ConsumePrescriptionRequest;
109bool operator==(const ConsumePrescriptionRequest&, const ConsumePrescriptionRequest&);
110bool operator<(const ConsumePrescriptionRequest&, const ConsumePrescriptionRequest&);
111
112class ListDocumentsRequest;
113bool operator==(const ListDocumentsRequest&, const ListDocumentsRequest&);
114bool operator<(const ListDocumentsRequest&, const ListDocumentsRequest&);
115
116class FindDocumentsRequest;
117bool operator==(const FindDocumentsRequest&, const FindDocumentsRequest&);
118bool operator<(const FindDocumentsRequest&, const FindDocumentsRequest&);
119
120class CreatePermissionRequest;
121bool operator==(const CreatePermissionRequest&, const CreatePermissionRequest&);
122bool operator<(const CreatePermissionRequest&, const CreatePermissionRequest&);
123
124class SetDefaultAccessRequest;
125bool operator==(const SetDefaultAccessRequest&, const SetDefaultAccessRequest&);
126bool operator<(const SetDefaultAccessRequest&, const SetDefaultAccessRequest&);
127
128class ListPermissionsRequest;
129bool operator==(const ListPermissionsRequest&, const ListPermissionsRequest&);
130bool operator<(const ListPermissionsRequest&, const ListPermissionsRequest&);
131
132class RemovePermissionRequest;
133bool operator==(const RemovePermissionRequest&, const RemovePermissionRequest&);
134bool operator<(const RemovePermissionRequest&, const RemovePermissionRequest&);
135
136class Provider;
137bool operator==(const Provider&, const Provider&);
138bool operator<(const Provider&, const Provider&);
139
140}
141
142namespace IceInternal
143{
144
145::Ice::Object* upCast(::Ehr::Document*);
146::IceProxy::Ice::Object* upCast(::IceProxy::Ehr::Document*);
147
148::Ice::Object* upCast(::Ehr::Prescription*);
149::IceProxy::Ice::Object* upCast(::IceProxy::Ehr::Prescription*);
150
151::Ice::Object* upCast(::Ehr::ConsumedPrescription*);
152::IceProxy::Ice::Object* upCast(::IceProxy::Ehr::ConsumedPrescription*);
153
154::Ice::Object* upCast(::Ehr::Request*);
155::IceProxy::Ice::Object* upCast(::IceProxy::Ehr::Request*);
156
157::Ice::Object* upCast(::Ehr::ThirdPartyRequest*);
158::IceProxy::Ice::Object* upCast(::IceProxy::Ehr::ThirdPartyRequest*);
159
160::Ice::Object* upCast(::Ehr::CreatePrescriptionRequest*);
161::IceProxy::Ice::Object* upCast(::IceProxy::Ehr::CreatePrescriptionRequest*);
162
163::Ice::Object* upCast(::Ehr::ConsumePrescriptionRequest*);
164::IceProxy::Ice::Object* upCast(::IceProxy::Ehr::ConsumePrescriptionRequest*);
165
166::Ice::Object* upCast(::Ehr::ListDocumentsRequest*);
167::IceProxy::Ice::Object* upCast(::IceProxy::Ehr::ListDocumentsRequest*);
168
169::Ice::Object* upCast(::Ehr::FindDocumentsRequest*);
170::IceProxy::Ice::Object* upCast(::IceProxy::Ehr::FindDocumentsRequest*);
171
172::Ice::Object* upCast(::Ehr::CreatePermissionRequest*);
173::IceProxy::Ice::Object* upCast(::IceProxy::Ehr::CreatePermissionRequest*);
174
175::Ice::Object* upCast(::Ehr::SetDefaultAccessRequest*);
176::IceProxy::Ice::Object* upCast(::IceProxy::Ehr::SetDefaultAccessRequest*);
177
178::Ice::Object* upCast(::Ehr::ListPermissionsRequest*);
179::IceProxy::Ice::Object* upCast(::IceProxy::Ehr::ListPermissionsRequest*);
180
181::Ice::Object* upCast(::Ehr::RemovePermissionRequest*);
182::IceProxy::Ice::Object* upCast(::IceProxy::Ehr::RemovePermissionRequest*);
183
184::Ice::Object* upCast(::Ehr::Provider*);
185::IceProxy::Ice::Object* upCast(::IceProxy::Ehr::Provider*);
186
187}
188
189namespace Ehr
190{
191
192typedef ::IceInternal::Handle< ::Ehr::Document> DocumentPtr;
193typedef ::IceInternal::ProxyHandle< ::IceProxy::Ehr::Document> DocumentPrx;
194
195void __read(::IceInternal::BasicStream*, DocumentPrx&);
196void __patch__DocumentPtr(void*, ::Ice::ObjectPtr&);
197
198void ice_writeDocumentPrx(const ::Ice::OutputStreamPtr&, const DocumentPrx&);
199void ice_readDocumentPrx(const ::Ice::InputStreamPtr&, DocumentPrx&);
200void ice_writeDocument(const ::Ice::OutputStreamPtr&, const DocumentPtr&);
201void ice_readDocument(const ::Ice::InputStreamPtr&, DocumentPtr&);
202
203typedef ::IceInternal::Handle< ::Ehr::Prescription> PrescriptionPtr;
204typedef ::IceInternal::ProxyHandle< ::IceProxy::Ehr::Prescription> PrescriptionPrx;
205
206void __read(::IceInternal::BasicStream*, PrescriptionPrx&);
207void __patch__PrescriptionPtr(void*, ::Ice::ObjectPtr&);
208
209void ice_writePrescriptionPrx(const ::Ice::OutputStreamPtr&, const PrescriptionPrx&);
210void ice_readPrescriptionPrx(const ::Ice::InputStreamPtr&, PrescriptionPrx&);
211void ice_writePrescription(const ::Ice::OutputStreamPtr&, const PrescriptionPtr&);
212void ice_readPrescription(const ::Ice::InputStreamPtr&, PrescriptionPtr&);
213
214typedef ::IceInternal::Handle< ::Ehr::ConsumedPrescription> ConsumedPrescriptionPtr;
215typedef ::IceInternal::ProxyHandle< ::IceProxy::Ehr::ConsumedPrescription> ConsumedPrescriptionPrx;
216
217void __read(::IceInternal::BasicStream*, ConsumedPrescriptionPrx&);
218void __patch__ConsumedPrescriptionPtr(void*, ::Ice::ObjectPtr&);
219
220void ice_writeConsumedPrescriptionPrx(const ::Ice::OutputStreamPtr&, const ConsumedPrescriptionPrx&);
221void ice_readConsumedPrescriptionPrx(const ::Ice::InputStreamPtr&, ConsumedPrescriptionPrx&);
222void ice_writeConsumedPrescription(const ::Ice::OutputStreamPtr&, const ConsumedPrescriptionPtr&);
223void ice_readConsumedPrescription(const ::Ice::InputStreamPtr&, ConsumedPrescriptionPtr&);
224
225typedef ::IceInternal::Handle< ::Ehr::Request> RequestPtr;
226typedef ::IceInternal::ProxyHandle< ::IceProxy::Ehr::Request> RequestPrx;
227
228void __read(::IceInternal::BasicStream*, RequestPrx&);
229void __patch__RequestPtr(void*, ::Ice::ObjectPtr&);
230
231void ice_writeRequestPrx(const ::Ice::OutputStreamPtr&, const RequestPrx&);
232void ice_readRequestPrx(const ::Ice::InputStreamPtr&, RequestPrx&);
233void ice_writeRequest(const ::Ice::OutputStreamPtr&, const RequestPtr&);
234void ice_readRequest(const ::Ice::InputStreamPtr&, RequestPtr&);
235
236typedef ::IceInternal::Handle< ::Ehr::ThirdPartyRequest> ThirdPartyRequestPtr;
237typedef ::IceInternal::ProxyHandle< ::IceProxy::Ehr::ThirdPartyRequest> ThirdPartyRequestPrx;
238
239void __read(::IceInternal::BasicStream*, ThirdPartyRequestPrx&);
240void __patch__ThirdPartyRequestPtr(void*, ::Ice::ObjectPtr&);
241
242void ice_writeThirdPartyRequestPrx(const ::Ice::OutputStreamPtr&, const ThirdPartyRequestPrx&);
243void ice_readThirdPartyRequestPrx(const ::Ice::InputStreamPtr&, ThirdPartyRequestPrx&);
244void ice_writeThirdPartyRequest(const ::Ice::OutputStreamPtr&, const ThirdPartyRequestPtr&);
245void ice_readThirdPartyRequest(const ::Ice::InputStreamPtr&, ThirdPartyRequestPtr&);
246
247typedef ::IceInternal::Handle< ::Ehr::CreatePrescriptionRequest> CreatePrescriptionRequestPtr;
248typedef ::IceInternal::ProxyHandle< ::IceProxy::Ehr::CreatePrescriptionRequest> CreatePrescriptionRequestPrx;
249
250void __read(::IceInternal::BasicStream*, CreatePrescriptionRequestPrx&);
251void __patch__CreatePrescriptionRequestPtr(void*, ::Ice::ObjectPtr&);
252
253void ice_writeCreatePrescriptionRequestPrx(const ::Ice::OutputStreamPtr&, const CreatePrescriptionRequestPrx&);
254void ice_readCreatePrescriptionRequestPrx(const ::Ice::InputStreamPtr&, CreatePrescriptionRequestPrx&);
255void ice_writeCreatePrescriptionRequest(const ::Ice::OutputStreamPtr&, const CreatePrescriptionRequestPtr&);
256void ice_readCreatePrescriptionRequest(const ::Ice::InputStreamPtr&, CreatePrescriptionRequestPtr&);
257
258typedef ::IceInternal::Handle< ::Ehr::ConsumePrescriptionRequest> ConsumePrescriptionRequestPtr;
259typedef ::IceInternal::ProxyHandle< ::IceProxy::Ehr::ConsumePrescriptionRequest> ConsumePrescriptionRequestPrx;
260
261void __read(::IceInternal::BasicStream*, ConsumePrescriptionRequestPrx&);
262void __patch__ConsumePrescriptionRequestPtr(void*, ::Ice::ObjectPtr&);
263
264void ice_writeConsumePrescriptionRequestPrx(const ::Ice::OutputStreamPtr&, const ConsumePrescriptionRequestPrx&);
265void ice_readConsumePrescriptionRequestPrx(const ::Ice::InputStreamPtr&, ConsumePrescriptionRequestPrx&);
266void ice_writeConsumePrescriptionRequest(const ::Ice::OutputStreamPtr&, const ConsumePrescriptionRequestPtr&);
267void ice_readConsumePrescriptionRequest(const ::Ice::InputStreamPtr&, ConsumePrescriptionRequestPtr&);
268
269typedef ::IceInternal::Handle< ::Ehr::ListDocumentsRequest> ListDocumentsRequestPtr;
270typedef ::IceInternal::ProxyHandle< ::IceProxy::Ehr::ListDocumentsRequest> ListDocumentsRequestPrx;
271
272void __read(::IceInternal::BasicStream*, ListDocumentsRequestPrx&);
273void __patch__ListDocumentsRequestPtr(void*, ::Ice::ObjectPtr&);
274
275void ice_writeListDocumentsRequestPrx(const ::Ice::OutputStreamPtr&, const ListDocumentsRequestPrx&);
276void ice_readListDocumentsRequestPrx(const ::Ice::InputStreamPtr&, ListDocumentsRequestPrx&);
277void ice_writeListDocumentsRequest(const ::Ice::OutputStreamPtr&, const ListDocumentsRequestPtr&);
278void ice_readListDocumentsRequest(const ::Ice::InputStreamPtr&, ListDocumentsRequestPtr&);
279
280typedef ::IceInternal::Handle< ::Ehr::FindDocumentsRequest> FindDocumentsRequestPtr;
281typedef ::IceInternal::ProxyHandle< ::IceProxy::Ehr::FindDocumentsRequest> FindDocumentsRequestPrx;
282
283void __read(::IceInternal::BasicStream*, FindDocumentsRequestPrx&);
284void __patch__FindDocumentsRequestPtr(void*, ::Ice::ObjectPtr&);
285
286void ice_writeFindDocumentsRequestPrx(const ::Ice::OutputStreamPtr&, const FindDocumentsRequestPrx&);
287void ice_readFindDocumentsRequestPrx(const ::Ice::InputStreamPtr&, FindDocumentsRequestPrx&);
288void ice_writeFindDocumentsRequest(const ::Ice::OutputStreamPtr&, const FindDocumentsRequestPtr&);
289void ice_readFindDocumentsRequest(const ::Ice::InputStreamPtr&, FindDocumentsRequestPtr&);
290
291typedef ::IceInternal::Handle< ::Ehr::CreatePermissionRequest> CreatePermissionRequestPtr;
292typedef ::IceInternal::ProxyHandle< ::IceProxy::Ehr::CreatePermissionRequest> CreatePermissionRequestPrx;
293
294void __read(::IceInternal::BasicStream*, CreatePermissionRequestPrx&);
295void __patch__CreatePermissionRequestPtr(void*, ::Ice::ObjectPtr&);
296
297void ice_writeCreatePermissionRequestPrx(const ::Ice::OutputStreamPtr&, const CreatePermissionRequestPrx&);
298void ice_readCreatePermissionRequestPrx(const ::Ice::InputStreamPtr&, CreatePermissionRequestPrx&);
299void ice_writeCreatePermissionRequest(const ::Ice::OutputStreamPtr&, const CreatePermissionRequestPtr&);
300void ice_readCreatePermissionRequest(const ::Ice::InputStreamPtr&, CreatePermissionRequestPtr&);
301
302typedef ::IceInternal::Handle< ::Ehr::SetDefaultAccessRequest> SetDefaultAccessRequestPtr;
303typedef ::IceInternal::ProxyHandle< ::IceProxy::Ehr::SetDefaultAccessRequest> SetDefaultAccessRequestPrx;
304
305void __read(::IceInternal::BasicStream*, SetDefaultAccessRequestPrx&);
306void __patch__SetDefaultAccessRequestPtr(void*, ::Ice::ObjectPtr&);
307
308void ice_writeSetDefaultAccessRequestPrx(const ::Ice::OutputStreamPtr&, const SetDefaultAccessRequestPrx&);
309void ice_readSetDefaultAccessRequestPrx(const ::Ice::InputStreamPtr&, SetDefaultAccessRequestPrx&);
310void ice_writeSetDefaultAccessRequest(const ::Ice::OutputStreamPtr&, const SetDefaultAccessRequestPtr&);
311void ice_readSetDefaultAccessRequest(const ::Ice::InputStreamPtr&, SetDefaultAccessRequestPtr&);
312
313typedef ::IceInternal::Handle< ::Ehr::ListPermissionsRequest> ListPermissionsRequestPtr;
314typedef ::IceInternal::ProxyHandle< ::IceProxy::Ehr::ListPermissionsRequest> ListPermissionsRequestPrx;
315
316void __read(::IceInternal::BasicStream*, ListPermissionsRequestPrx&);
317void __patch__ListPermissionsRequestPtr(void*, ::Ice::ObjectPtr&);
318
319void ice_writeListPermissionsRequestPrx(const ::Ice::OutputStreamPtr&, const ListPermissionsRequestPrx&);
320void ice_readListPermissionsRequestPrx(const ::Ice::InputStreamPtr&, ListPermissionsRequestPrx&);
321void ice_writeListPermissionsRequest(const ::Ice::OutputStreamPtr&, const ListPermissionsRequestPtr&);
322void ice_readListPermissionsRequest(const ::Ice::InputStreamPtr&, ListPermissionsRequestPtr&);
323
324typedef ::IceInternal::Handle< ::Ehr::RemovePermissionRequest> RemovePermissionRequestPtr;
325typedef ::IceInternal::ProxyHandle< ::IceProxy::Ehr::RemovePermissionRequest> RemovePermissionRequestPrx;
326
327void __read(::IceInternal::BasicStream*, RemovePermissionRequestPrx&);
328void __patch__RemovePermissionRequestPtr(void*, ::Ice::ObjectPtr&);
329
330void ice_writeRemovePermissionRequestPrx(const ::Ice::OutputStreamPtr&, const RemovePermissionRequestPrx&);
331void ice_readRemovePermissionRequestPrx(const ::Ice::InputStreamPtr&, RemovePermissionRequestPrx&);
332void ice_writeRemovePermissionRequest(const ::Ice::OutputStreamPtr&, const RemovePermissionRequestPtr&);
333void ice_readRemovePermissionRequest(const ::Ice::InputStreamPtr&, RemovePermissionRequestPtr&);
334
335typedef ::IceInternal::Handle< ::Ehr::Provider> ProviderPtr;
336typedef ::IceInternal::ProxyHandle< ::IceProxy::Ehr::Provider> ProviderPrx;
337
338void __read(::IceInternal::BasicStream*, ProviderPrx&);
339void __patch__ProviderPtr(void*, ::Ice::ObjectPtr&);
340
341void ice_writeProviderPrx(const ::Ice::OutputStreamPtr&, const ProviderPrx&);
342void ice_readProviderPrx(const ::Ice::InputStreamPtr&, ProviderPrx&);
343void ice_writeProvider(const ::Ice::OutputStreamPtr&, const ProviderPtr&);
344void ice_readProvider(const ::Ice::InputStreamPtr&, ProviderPtr&);
345
346}
347
348namespace Ehr
349{
350
351typedef ::std::vector< ::Ice::Byte> ByteSeq;
352
353class EhrException : public ::Ice::UserException
354{
355public:
356
357 EhrException() {}
358 explicit EhrException(const ::std::string&);
359 virtual ~EhrException() throw();
360
361 virtual ::std::string ice_name() const;
362 virtual ::Ice::Exception* ice_clone() const;
363 virtual void ice_throw() const;
364
365 static const ::IceInternal::UserExceptionFactoryPtr& ice_factory();
366
367 ::std::string what;
368
369 virtual void __write(::IceInternal::BasicStream*) const;
370 virtual void __read(::IceInternal::BasicStream*, bool);
371 virtual void __write(const ::Ice::OutputStreamPtr&) const;
372 virtual void __read(const ::Ice::InputStreamPtr&, bool);
373};
374
375static EhrException __EhrException_init;
376
377class InvalidRequestException : public ::Ehr::EhrException
378{
379public:
380
381 InvalidRequestException() {}
382 explicit InvalidRequestException(const ::std::string&);
383 virtual ~InvalidRequestException() throw();
384
385 virtual ::std::string ice_name() const;
386 virtual ::Ice::Exception* ice_clone() const;
387 virtual void ice_throw() const;
388
389 static const ::IceInternal::UserExceptionFactoryPtr& ice_factory();
390
391 virtual void __write(::IceInternal::BasicStream*) const;
392 virtual void __read(::IceInternal::BasicStream*, bool);
393 virtual void __write(const ::Ice::OutputStreamPtr&) const;
394 virtual void __read(const ::Ice::InputStreamPtr&, bool);
395};
396
397class InvalidAccountException : public ::Ehr::InvalidRequestException
398{
399public:
400
401 InvalidAccountException() {}
402 explicit InvalidAccountException(const ::std::string&);
403 virtual ~InvalidAccountException() throw();
404
405 virtual ::std::string ice_name() const;
406 virtual ::Ice::Exception* ice_clone() const;
407 virtual void ice_throw() const;
408
409 static const ::IceInternal::UserExceptionFactoryPtr& ice_factory();
410
411 virtual void __write(::IceInternal::BasicStream*) const;
412 virtual void __read(::IceInternal::BasicStream*, bool);
413 virtual void __write(const ::Ice::OutputStreamPtr&) const;
414 virtual void __read(const ::Ice::InputStreamPtr&, bool);
415};
416
417class SignatureException : public ::Ehr::EhrException
418{
419public:
420
421 SignatureException() {}
422 explicit SignatureException(const ::std::string&);
423 virtual ~SignatureException() throw();
424
425 virtual ::std::string ice_name() const;
426 virtual ::Ice::Exception* ice_clone() const;
427 virtual void ice_throw() const;
428
429 static const ::IceInternal::UserExceptionFactoryPtr& ice_factory();
430
431 virtual void __write(::IceInternal::BasicStream*) const;
432 virtual void __read(::IceInternal::BasicStream*, bool);
433 virtual void __write(const ::Ice::OutputStreamPtr&) const;
434 virtual void __read(const ::Ice::InputStreamPtr&, bool);
435};
436
437class PermissionDeniedException : public ::Ehr::EhrException
438{
439public:
440
441 PermissionDeniedException() {}
442 explicit PermissionDeniedException(const ::std::string&);
443 virtual ~PermissionDeniedException() throw();
444
445 virtual ::std::string ice_name() const;
446 virtual ::Ice::Exception* ice_clone() const;
447 virtual void ice_throw() const;
448
449 static const ::IceInternal::UserExceptionFactoryPtr& ice_factory();
450
451 virtual void __write(::IceInternal::BasicStream*) const;
452 virtual void __read(::IceInternal::BasicStream*, bool);
453 virtual void __write(const ::Ice::OutputStreamPtr&) const;
454 virtual void __read(const ::Ice::InputStreamPtr&, bool);
455};
456
457struct AccountIdentifier
458{
459 ::std::string user;
460 ::std::string provider;
461
462 bool operator==(const AccountIdentifier&) const;
463 bool operator<(const AccountIdentifier&) const;
464 bool operator!=(const AccountIdentifier& __rhs) const
465 {
466 return !operator==(__rhs);
467 }
468 bool operator<=(const AccountIdentifier& __rhs) const
469 {
470 return operator<(__rhs) || operator==(__rhs);
471 }
472 bool operator>(const AccountIdentifier& __rhs) const
473 {
474 return !operator<(__rhs) && !operator==(__rhs);
475 }
476 bool operator>=(const AccountIdentifier& __rhs) const
477 {
478 return !operator<(__rhs);
479 }
480
481 void __write(::IceInternal::BasicStream*) const;
482 void __read(::IceInternal::BasicStream*);
483
484 void ice_write(const ::Ice::OutputStreamPtr&) const;
485 void ice_read(const ::Ice::InputStreamPtr&);
486};
487
488void ice_writeAccountIdentifier(const ::Ice::OutputStreamPtr&, const AccountIdentifier&);
489void ice_readAccountIdentifier(const ::Ice::InputStreamPtr&, AccountIdentifier&);
490
491enum DocumentType
492{
493 DOCANY,
494 DOCPRESCRIPTION,
495 DOCCONSUMEDPRESCRIPTION
496};
497
498void __write(::IceInternal::BasicStream*, DocumentType);
499void __read(::IceInternal::BasicStream*, DocumentType&);
500
501void ice_writeDocumentType(const ::Ice::OutputStreamPtr&, DocumentType);
502void ice_readDocumentType(const ::Ice::InputStreamPtr&, DocumentType&);
503
504struct Signature
505{
506 ::Ehr::ByteSeq data;
507
508 bool operator==(const Signature&) const;
509 bool operator<(const Signature&) const;
510 bool operator!=(const Signature& __rhs) const
511 {
512 return !operator==(__rhs);
513 }
514 bool operator<=(const Signature& __rhs) const
515 {
516 return operator<(__rhs) || operator==(__rhs);
517 }
518 bool operator>(const Signature& __rhs) const
519 {
520 return !operator<(__rhs) && !operator==(__rhs);
521 }
522 bool operator>=(const Signature& __rhs) const
523 {
524 return !operator<(__rhs);
525 }
526
527 void __write(::IceInternal::BasicStream*) const;
528 void __read(::IceInternal::BasicStream*);
529
530 void ice_write(const ::Ice::OutputStreamPtr&) const;
531 void ice_read(const ::Ice::InputStreamPtr&);
532};
533
534void ice_writeSignature(const ::Ice::OutputStreamPtr&, const Signature&);
535void ice_readSignature(const ::Ice::InputStreamPtr&, Signature&);
536
537struct Timestamp
538{
539 ::Ice::Long msecs;
540
541 bool operator==(const Timestamp&) const;
542 bool operator<(const Timestamp&) const;
543 bool operator!=(const Timestamp& __rhs) const
544 {
545 return !operator==(__rhs);
546 }
547 bool operator<=(const Timestamp& __rhs) const
548 {
549 return operator<(__rhs) || operator==(__rhs);
550 }
551 bool operator>(const Timestamp& __rhs) const
552 {
553 return !operator<(__rhs) && !operator==(__rhs);
554 }
555 bool operator>=(const Timestamp& __rhs) const
556 {
557 return !operator<(__rhs);
558 }
559
560 void __write(::IceInternal::BasicStream*) const;
561 void __read(::IceInternal::BasicStream*);
562
563 void ice_write(const ::Ice::OutputStreamPtr&) const;
564 void ice_read(const ::Ice::InputStreamPtr&);
565};
566
567void ice_writeTimestamp(const ::Ice::OutputStreamPtr&, const Timestamp&);
568void ice_readTimestamp(const ::Ice::InputStreamPtr&, Timestamp&);
569
570struct Date
571{
572 ::Ice::Byte day;
573 ::Ice::Byte month;
574 ::Ice::Short year;
575
576 bool operator==(const Date&) const;
577 bool operator<(const Date&) const;
578 bool operator!=(const Date& __rhs) const
579 {
580 return !operator==(__rhs);
581 }
582 bool operator<=(const Date& __rhs) const
583 {
584 return operator<(__rhs) || operator==(__rhs);
585 }
586 bool operator>(const Date& __rhs) const
587 {
588 return !operator<(__rhs) && !operator==(__rhs);
589 }
590 bool operator>=(const Date& __rhs) const
591 {
592 return !operator<(__rhs);
593 }
594
595 void __write(::IceInternal::BasicStream*) const;
596 void __read(::IceInternal::BasicStream*);
597
598 void ice_write(const ::Ice::OutputStreamPtr&) const;
599 void ice_read(const ::Ice::InputStreamPtr&);
600};
601
602void ice_writeDate(const ::Ice::OutputStreamPtr&, const Date&);
603void ice_readDate(const ::Ice::InputStreamPtr&, Date&);
604
605enum AccessType
606{
607 ALLOW,
608 DENY
609};
610
611void __write(::IceInternal::BasicStream*, AccessType);
612void __read(::IceInternal::BasicStream*, AccessType&);
613
614void ice_writeAccessType(const ::Ice::OutputStreamPtr&, AccessType);
615void ice_readAccessType(const ::Ice::InputStreamPtr&, AccessType&);
616
617struct EncryptedDocument
618{
619 ::Ehr::ByteSeq encryptedKey;
620 ::Ehr::ByteSeq initialVector;
621 ::Ehr::ByteSeq encryptedData;
622
623 bool operator==(const EncryptedDocument&) const;
624 bool operator<(const EncryptedDocument&) const;
625 bool operator!=(const EncryptedDocument& __rhs) const
626 {
627 return !operator==(__rhs);
628 }
629 bool operator<=(const EncryptedDocument& __rhs) const
630 {
631 return operator<(__rhs) || operator==(__rhs);
632 }
633 bool operator>(const EncryptedDocument& __rhs) const
634 {
635 return !operator<(__rhs) && !operator==(__rhs);
636 }
637 bool operator>=(const EncryptedDocument& __rhs) const
638 {
639 return !operator<(__rhs);
640 }
641
642 void __write(::IceInternal::BasicStream*) const;
643 void __read(::IceInternal::BasicStream*);
644
645 void ice_write(const ::Ice::OutputStreamPtr&) const;
646 void ice_read(const ::Ice::InputStreamPtr&);
647};
648
649void ice_writeEncryptedDocument(const ::Ice::OutputStreamPtr&, const EncryptedDocument&);
650void ice_readEncryptedDocument(const ::Ice::InputStreamPtr&, EncryptedDocument&);
651
652struct DocumentListItem
653{
654 ::Ice::Long id;
655 ::Ehr::Timestamp created;
656 ::Ehr::EncryptedDocument document;
657
658 bool operator==(const DocumentListItem&) const;
659 bool operator<(const DocumentListItem&) const;
660 bool operator!=(const DocumentListItem& __rhs) const
661 {
662 return !operator==(__rhs);
663 }
664 bool operator<=(const DocumentListItem& __rhs) const
665 {
666 return operator<(__rhs) || operator==(__rhs);
667 }
668 bool operator>(const DocumentListItem& __rhs) const
669 {
670 return !operator<(__rhs) && !operator==(__rhs);
671 }
672 bool operator>=(const DocumentListItem& __rhs) const
673 {
674 return !operator<(__rhs);
675 }
676
677 void __write(::IceInternal::BasicStream*) const;
678 void __read(::IceInternal::BasicStream*);
679
680 void ice_write(const ::Ice::OutputStreamPtr&) const;
681 void ice_read(const ::Ice::InputStreamPtr&);
682};
683
684void ice_writeDocumentListItem(const ::Ice::OutputStreamPtr&, const DocumentListItem&);
685void ice_readDocumentListItem(const ::Ice::InputStreamPtr&, DocumentListItem&);
686
687typedef ::std::vector< ::Ehr::DocumentListItem> DocumentList;
688void __writeDocumentList(::IceInternal::BasicStream*, const ::Ehr::DocumentListItem*, const ::Ehr::DocumentListItem*);
689void __readDocumentList(::IceInternal::BasicStream*, DocumentList&);
690void ice_writeDocumentList(const ::Ice::OutputStreamPtr&, const DocumentList&);
691void ice_readDocumentList(const ::Ice::InputStreamPtr&, DocumentList&);
692
693struct AccessControlListItem
694{
695 ::Ice::Long id;
696 ::Ehr::AccountIdentifier account;
697 ::Ehr::AccessType access;
698
699 bool operator==(const AccessControlListItem&) const;
700 bool operator<(const AccessControlListItem&) const;
701 bool operator!=(const AccessControlListItem& __rhs) const
702 {
703 return !operator==(__rhs);
704 }
705 bool operator<=(const AccessControlListItem& __rhs) const
706 {
707 return operator<(__rhs) || operator==(__rhs);
708 }
709 bool operator>(const AccessControlListItem& __rhs) const
710 {
711 return !operator<(__rhs) && !operator==(__rhs);
712 }
713 bool operator>=(const AccessControlListItem& __rhs) const
714 {
715 return !operator<(__rhs);
716 }
717
718 void __write(::IceInternal::BasicStream*) const;
719 void __read(::IceInternal::BasicStream*);
720
721 void ice_write(const ::Ice::OutputStreamPtr&) const;
722 void ice_read(const ::Ice::InputStreamPtr&);
723};
724
725void ice_writeAccessControlListItem(const ::Ice::OutputStreamPtr&, const AccessControlListItem&);
726void ice_readAccessControlListItem(const ::Ice::InputStreamPtr&, AccessControlListItem&);
727
728typedef ::std::vector< ::Ehr::AccessControlListItem> AccessControlList;
729void __writeAccessControlList(::IceInternal::BasicStream*, const ::Ehr::AccessControlListItem*, const ::Ehr::AccessControlListItem*);
730void __readAccessControlList(::IceInternal::BasicStream*, AccessControlList&);
731void ice_writeAccessControlList(const ::Ice::OutputStreamPtr&, const AccessControlList&);
732void ice_readAccessControlList(const ::Ice::InputStreamPtr&, AccessControlList&);
733
734struct Permissions
735{
736 ::Ehr::AccessType defaultAccess;
737 ::Ehr::AccessControlList acl;
738
739 bool operator==(const Permissions&) const;
740 bool operator<(const Permissions&) const;
741 bool operator!=(const Permissions& __rhs) const
742 {
743 return !operator==(__rhs);
744 }
745 bool operator<=(const Permissions& __rhs) const
746 {
747 return operator<(__rhs) || operator==(__rhs);
748 }
749 bool operator>(const Permissions& __rhs) const
750 {
751 return !operator<(__rhs) && !operator==(__rhs);
752 }
753 bool operator>=(const Permissions& __rhs) const
754 {
755 return !operator<(__rhs);
756 }
757
758 void __write(::IceInternal::BasicStream*) const;
759 void __read(::IceInternal::BasicStream*);
760
761 void ice_write(const ::Ice::OutputStreamPtr&) const;
762 void ice_read(const ::Ice::InputStreamPtr&);
763};
764
765void ice_writePermissions(const ::Ice::OutputStreamPtr&, const Permissions&);
766void ice_readPermissions(const ::Ice::InputStreamPtr&, Permissions&);
767
768}
769
770namespace IceProxy
771{
772
773namespace Ehr
774{
775
776class Document : virtual public ::IceProxy::Ice::Object
777{
778public:
779
780 ::IceInternal::ProxyHandle<Document> ice_context(const ::Ice::Context& __context) const
781 {
782 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
783 typedef ::IceProxy::Ice::Object _Base;
784 return dynamic_cast<Document*>(_Base::ice_context(__context).get());
785 #else
786 return dynamic_cast<Document*>(::IceProxy::Ice::Object::ice_context(__context).get());
787 #endif
788 }
789
790 ::IceInternal::ProxyHandle<Document> ice_adapterId(const std::string& __id) const
791 {
792 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
793 typedef ::IceProxy::Ice::Object _Base;
794 return dynamic_cast<Document*>(_Base::ice_adapterId(__id).get());
795 #else
796 return dynamic_cast<Document*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
797 #endif
798 }
799
800 ::IceInternal::ProxyHandle<Document> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
801 {
802 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
803 typedef ::IceProxy::Ice::Object _Base;
804 return dynamic_cast<Document*>(_Base::ice_endpoints(__endpoints).get());
805 #else
806 return dynamic_cast<Document*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
807 #endif
808 }
809
810 ::IceInternal::ProxyHandle<Document> ice_locatorCacheTimeout(int __timeout) const
811 {
812 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
813 typedef ::IceProxy::Ice::Object _Base;
814 return dynamic_cast<Document*>(_Base::ice_locatorCacheTimeout(__timeout).get());
815 #else
816 return dynamic_cast<Document*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
817 #endif
818 }
819
820 ::IceInternal::ProxyHandle<Document> ice_connectionCached(bool __cached) const
821 {
822 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
823 typedef ::IceProxy::Ice::Object _Base;
824 return dynamic_cast<Document*>(_Base::ice_connectionCached(__cached).get());
825 #else
826 return dynamic_cast<Document*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
827 #endif
828 }
829
830 ::IceInternal::ProxyHandle<Document> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
831 {
832 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
833 typedef ::IceProxy::Ice::Object _Base;
834 return dynamic_cast<Document*>(_Base::ice_endpointSelection(__est).get());
835 #else
836 return dynamic_cast<Document*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
837 #endif
838 }
839
840 ::IceInternal::ProxyHandle<Document> ice_secure(bool __secure) const
841 {
842 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
843 typedef ::IceProxy::Ice::Object _Base;
844 return dynamic_cast<Document*>(_Base::ice_secure(__secure).get());
845 #else
846 return dynamic_cast<Document*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
847 #endif
848 }
849
850 ::IceInternal::ProxyHandle<Document> ice_preferSecure(bool __preferSecure) const
851 {
852 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
853 typedef ::IceProxy::Ice::Object _Base;
854 return dynamic_cast<Document*>(_Base::ice_preferSecure(__preferSecure).get());
855 #else
856 return dynamic_cast<Document*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
857 #endif
858 }
859
860 ::IceInternal::ProxyHandle<Document> ice_router(const ::Ice::RouterPrx& __router) const
861 {
862 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
863 typedef ::IceProxy::Ice::Object _Base;
864 return dynamic_cast<Document*>(_Base::ice_router(__router).get());
865 #else
866 return dynamic_cast<Document*>(::IceProxy::Ice::Object::ice_router(__router).get());
867 #endif
868 }
869
870 ::IceInternal::ProxyHandle<Document> ice_locator(const ::Ice::LocatorPrx& __locator) const
871 {
872 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
873 typedef ::IceProxy::Ice::Object _Base;
874 return dynamic_cast<Document*>(_Base::ice_locator(__locator).get());
875 #else
876 return dynamic_cast<Document*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
877 #endif
878 }
879
880 ::IceInternal::ProxyHandle<Document> ice_collocationOptimized(bool __co) const
881 {
882 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
883 typedef ::IceProxy::Ice::Object _Base;
884 return dynamic_cast<Document*>(_Base::ice_collocationOptimized(__co).get());
885 #else
886 return dynamic_cast<Document*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
887 #endif
888 }
889
890 ::IceInternal::ProxyHandle<Document> ice_twoway() const
891 {
892 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
893 typedef ::IceProxy::Ice::Object _Base;
894 return dynamic_cast<Document*>(_Base::ice_twoway().get());
895 #else
896 return dynamic_cast<Document*>(::IceProxy::Ice::Object::ice_twoway().get());
897 #endif
898 }
899
900 ::IceInternal::ProxyHandle<Document> ice_oneway() const
901 {
902 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
903 typedef ::IceProxy::Ice::Object _Base;
904 return dynamic_cast<Document*>(_Base::ice_oneway().get());
905 #else
906 return dynamic_cast<Document*>(::IceProxy::Ice::Object::ice_oneway().get());
907 #endif
908 }
909
910 ::IceInternal::ProxyHandle<Document> ice_batchOneway() const
911 {
912 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
913 typedef ::IceProxy::Ice::Object _Base;
914 return dynamic_cast<Document*>(_Base::ice_batchOneway().get());
915 #else
916 return dynamic_cast<Document*>(::IceProxy::Ice::Object::ice_batchOneway().get());
917 #endif
918 }
919
920 ::IceInternal::ProxyHandle<Document> ice_datagram() const
921 {
922 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
923 typedef ::IceProxy::Ice::Object _Base;
924 return dynamic_cast<Document*>(_Base::ice_datagram().get());
925 #else
926 return dynamic_cast<Document*>(::IceProxy::Ice::Object::ice_datagram().get());
927 #endif
928 }
929
930 ::IceInternal::ProxyHandle<Document> ice_batchDatagram() const
931 {
932 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
933 typedef ::IceProxy::Ice::Object _Base;
934 return dynamic_cast<Document*>(_Base::ice_batchDatagram().get());
935 #else
936 return dynamic_cast<Document*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
937 #endif
938 }
939
940 ::IceInternal::ProxyHandle<Document> ice_compress(bool __compress) const
941 {
942 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
943 typedef ::IceProxy::Ice::Object _Base;
944 return dynamic_cast<Document*>(_Base::ice_compress(__compress).get());
945 #else
946 return dynamic_cast<Document*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
947 #endif
948 }
949
950 ::IceInternal::ProxyHandle<Document> ice_timeout(int __timeout) const
951 {
952 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
953 typedef ::IceProxy::Ice::Object _Base;
954 return dynamic_cast<Document*>(_Base::ice_timeout(__timeout).get());
955 #else
956 return dynamic_cast<Document*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
957 #endif
958 }
959
960 ::IceInternal::ProxyHandle<Document> ice_connectionId(const std::string& __id) const
961 {
962 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
963 typedef ::IceProxy::Ice::Object _Base;
964 return dynamic_cast<Document*>(_Base::ice_connectionId(__id).get());
965 #else
966 return dynamic_cast<Document*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
967 #endif
968 }
969
970 static const ::std::string& ice_staticId();
971
972private:
973
974 virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
975 virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
976 virtual ::IceProxy::Ice::Object* __newInstance() const;
977};
978
979class Prescription : virtual public ::IceProxy::Ehr::Document
980{
981public:
982
983 ::IceInternal::ProxyHandle<Prescription> ice_context(const ::Ice::Context& __context) const
984 {
985 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
986 typedef ::IceProxy::Ice::Object _Base;
987 return dynamic_cast<Prescription*>(_Base::ice_context(__context).get());
988 #else
989 return dynamic_cast<Prescription*>(::IceProxy::Ice::Object::ice_context(__context).get());
990 #endif
991 }
992
993 ::IceInternal::ProxyHandle<Prescription> ice_adapterId(const std::string& __id) const
994 {
995 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
996 typedef ::IceProxy::Ice::Object _Base;
997 return dynamic_cast<Prescription*>(_Base::ice_adapterId(__id).get());
998 #else
999 return dynamic_cast<Prescription*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
1000 #endif
1001 }
1002
1003 ::IceInternal::ProxyHandle<Prescription> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
1004 {
1005 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1006 typedef ::IceProxy::Ice::Object _Base;
1007 return dynamic_cast<Prescription*>(_Base::ice_endpoints(__endpoints).get());
1008 #else
1009 return dynamic_cast<Prescription*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
1010 #endif
1011 }
1012
1013 ::IceInternal::ProxyHandle<Prescription> ice_locatorCacheTimeout(int __timeout) const
1014 {
1015 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1016 typedef ::IceProxy::Ice::Object _Base;
1017 return dynamic_cast<Prescription*>(_Base::ice_locatorCacheTimeout(__timeout).get());
1018 #else
1019 return dynamic_cast<Prescription*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
1020 #endif
1021 }
1022
1023 ::IceInternal::ProxyHandle<Prescription> ice_connectionCached(bool __cached) const
1024 {
1025 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1026 typedef ::IceProxy::Ice::Object _Base;
1027 return dynamic_cast<Prescription*>(_Base::ice_connectionCached(__cached).get());
1028 #else
1029 return dynamic_cast<Prescription*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
1030 #endif
1031 }
1032
1033 ::IceInternal::ProxyHandle<Prescription> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
1034 {
1035 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1036 typedef ::IceProxy::Ice::Object _Base;
1037 return dynamic_cast<Prescription*>(_Base::ice_endpointSelection(__est).get());
1038 #else
1039 return dynamic_cast<Prescription*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
1040 #endif
1041 }
1042
1043 ::IceInternal::ProxyHandle<Prescription> ice_secure(bool __secure) const
1044 {
1045 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1046 typedef ::IceProxy::Ice::Object _Base;
1047 return dynamic_cast<Prescription*>(_Base::ice_secure(__secure).get());
1048 #else
1049 return dynamic_cast<Prescription*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
1050 #endif
1051 }
1052
1053 ::IceInternal::ProxyHandle<Prescription> ice_preferSecure(bool __preferSecure) const
1054 {
1055 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1056 typedef ::IceProxy::Ice::Object _Base;
1057 return dynamic_cast<Prescription*>(_Base::ice_preferSecure(__preferSecure).get());
1058 #else
1059 return dynamic_cast<Prescription*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
1060 #endif
1061 }
1062
1063 ::IceInternal::ProxyHandle<Prescription> ice_router(const ::Ice::RouterPrx& __router) const
1064 {
1065 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1066 typedef ::IceProxy::Ice::Object _Base;
1067 return dynamic_cast<Prescription*>(_Base::ice_router(__router).get());
1068 #else
1069 return dynamic_cast<Prescription*>(::IceProxy::Ice::Object::ice_router(__router).get());
1070 #endif
1071 }
1072
1073 ::IceInternal::ProxyHandle<Prescription> ice_locator(const ::Ice::LocatorPrx& __locator) const
1074 {
1075 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1076 typedef ::IceProxy::Ice::Object _Base;
1077 return dynamic_cast<Prescription*>(_Base::ice_locator(__locator).get());
1078 #else
1079 return dynamic_cast<Prescription*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
1080 #endif
1081 }
1082
1083 ::IceInternal::ProxyHandle<Prescription> ice_collocationOptimized(bool __co) const
1084 {
1085 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1086 typedef ::IceProxy::Ice::Object _Base;
1087 return dynamic_cast<Prescription*>(_Base::ice_collocationOptimized(__co).get());
1088 #else
1089 return dynamic_cast<Prescription*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
1090 #endif
1091 }
1092
1093 ::IceInternal::ProxyHandle<Prescription> ice_twoway() const
1094 {
1095 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1096 typedef ::IceProxy::Ice::Object _Base;
1097 return dynamic_cast<Prescription*>(_Base::ice_twoway().get());
1098 #else
1099 return dynamic_cast<Prescription*>(::IceProxy::Ice::Object::ice_twoway().get());
1100 #endif
1101 }
1102
1103 ::IceInternal::ProxyHandle<Prescription> ice_oneway() const
1104 {
1105 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1106 typedef ::IceProxy::Ice::Object _Base;
1107 return dynamic_cast<Prescription*>(_Base::ice_oneway().get());
1108 #else
1109 return dynamic_cast<Prescription*>(::IceProxy::Ice::Object::ice_oneway().get());
1110 #endif
1111 }
1112
1113 ::IceInternal::ProxyHandle<Prescription> ice_batchOneway() const
1114 {
1115 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1116 typedef ::IceProxy::Ice::Object _Base;
1117 return dynamic_cast<Prescription*>(_Base::ice_batchOneway().get());
1118 #else
1119 return dynamic_cast<Prescription*>(::IceProxy::Ice::Object::ice_batchOneway().get());
1120 #endif
1121 }
1122
1123 ::IceInternal::ProxyHandle<Prescription> ice_datagram() const
1124 {
1125 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1126 typedef ::IceProxy::Ice::Object _Base;
1127 return dynamic_cast<Prescription*>(_Base::ice_datagram().get());
1128 #else
1129 return dynamic_cast<Prescription*>(::IceProxy::Ice::Object::ice_datagram().get());
1130 #endif
1131 }
1132
1133 ::IceInternal::ProxyHandle<Prescription> ice_batchDatagram() const
1134 {
1135 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1136 typedef ::IceProxy::Ice::Object _Base;
1137 return dynamic_cast<Prescription*>(_Base::ice_batchDatagram().get());
1138 #else
1139 return dynamic_cast<Prescription*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
1140 #endif
1141 }
1142
1143 ::IceInternal::ProxyHandle<Prescription> ice_compress(bool __compress) const
1144 {
1145 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1146 typedef ::IceProxy::Ice::Object _Base;
1147 return dynamic_cast<Prescription*>(_Base::ice_compress(__compress).get());
1148 #else
1149 return dynamic_cast<Prescription*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
1150 #endif
1151 }
1152
1153 ::IceInternal::ProxyHandle<Prescription> ice_timeout(int __timeout) const
1154 {
1155 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1156 typedef ::IceProxy::Ice::Object _Base;
1157 return dynamic_cast<Prescription*>(_Base::ice_timeout(__timeout).get());
1158 #else
1159 return dynamic_cast<Prescription*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
1160 #endif
1161 }
1162
1163 ::IceInternal::ProxyHandle<Prescription> ice_connectionId(const std::string& __id) const
1164 {
1165 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1166 typedef ::IceProxy::Ice::Object _Base;
1167 return dynamic_cast<Prescription*>(_Base::ice_connectionId(__id).get());
1168 #else
1169 return dynamic_cast<Prescription*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
1170 #endif
1171 }
1172
1173 static const ::std::string& ice_staticId();
1174
1175private:
1176
1177 virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
1178 virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
1179 virtual ::IceProxy::Ice::Object* __newInstance() const;
1180};
1181
1182class ConsumedPrescription : virtual public ::IceProxy::Ehr::Prescription
1183{
1184public:
1185
1186 ::IceInternal::ProxyHandle<ConsumedPrescription> ice_context(const ::Ice::Context& __context) const
1187 {
1188 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1189 typedef ::IceProxy::Ice::Object _Base;
1190 return dynamic_cast<ConsumedPrescription*>(_Base::ice_context(__context).get());
1191 #else
1192 return dynamic_cast<ConsumedPrescription*>(::IceProxy::Ice::Object::ice_context(__context).get());
1193 #endif
1194 }
1195
1196 ::IceInternal::ProxyHandle<ConsumedPrescription> ice_adapterId(const std::string& __id) const
1197 {
1198 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1199 typedef ::IceProxy::Ice::Object _Base;
1200 return dynamic_cast<ConsumedPrescription*>(_Base::ice_adapterId(__id).get());
1201 #else
1202 return dynamic_cast<ConsumedPrescription*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
1203 #endif
1204 }
1205
1206 ::IceInternal::ProxyHandle<ConsumedPrescription> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
1207 {
1208 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1209 typedef ::IceProxy::Ice::Object _Base;
1210 return dynamic_cast<ConsumedPrescription*>(_Base::ice_endpoints(__endpoints).get());
1211 #else
1212 return dynamic_cast<ConsumedPrescription*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
1213 #endif
1214 }
1215
1216 ::IceInternal::ProxyHandle<ConsumedPrescription> ice_locatorCacheTimeout(int __timeout) const
1217 {
1218 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1219 typedef ::IceProxy::Ice::Object _Base;
1220 return dynamic_cast<ConsumedPrescription*>(_Base::ice_locatorCacheTimeout(__timeout).get());
1221 #else
1222 return dynamic_cast<ConsumedPrescription*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
1223 #endif
1224 }
1225
1226 ::IceInternal::ProxyHandle<ConsumedPrescription> ice_connectionCached(bool __cached) const
1227 {
1228 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1229 typedef ::IceProxy::Ice::Object _Base;
1230 return dynamic_cast<ConsumedPrescription*>(_Base::ice_connectionCached(__cached).get());
1231 #else
1232 return dynamic_cast<ConsumedPrescription*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
1233 #endif
1234 }
1235
1236 ::IceInternal::ProxyHandle<ConsumedPrescription> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
1237 {
1238 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1239 typedef ::IceProxy::Ice::Object _Base;
1240 return dynamic_cast<ConsumedPrescription*>(_Base::ice_endpointSelection(__est).get());
1241 #else
1242 return dynamic_cast<ConsumedPrescription*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
1243 #endif
1244 }
1245
1246 ::IceInternal::ProxyHandle<ConsumedPrescription> ice_secure(bool __secure) const
1247 {
1248 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1249 typedef ::IceProxy::Ice::Object _Base;
1250 return dynamic_cast<ConsumedPrescription*>(_Base::ice_secure(__secure).get());
1251 #else
1252 return dynamic_cast<ConsumedPrescription*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
1253 #endif
1254 }
1255
1256 ::IceInternal::ProxyHandle<ConsumedPrescription> ice_preferSecure(bool __preferSecure) const
1257 {
1258 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1259 typedef ::IceProxy::Ice::Object _Base;
1260 return dynamic_cast<ConsumedPrescription*>(_Base::ice_preferSecure(__preferSecure).get());
1261 #else
1262 return dynamic_cast<ConsumedPrescription*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
1263 #endif
1264 }
1265
1266 ::IceInternal::ProxyHandle<ConsumedPrescription> ice_router(const ::Ice::RouterPrx& __router) const
1267 {
1268 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1269 typedef ::IceProxy::Ice::Object _Base;
1270 return dynamic_cast<ConsumedPrescription*>(_Base::ice_router(__router).get());
1271 #else
1272 return dynamic_cast<ConsumedPrescription*>(::IceProxy::Ice::Object::ice_router(__router).get());
1273 #endif
1274 }
1275
1276 ::IceInternal::ProxyHandle<ConsumedPrescription> ice_locator(const ::Ice::LocatorPrx& __locator) const
1277 {
1278 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1279 typedef ::IceProxy::Ice::Object _Base;
1280 return dynamic_cast<ConsumedPrescription*>(_Base::ice_locator(__locator).get());
1281 #else
1282 return dynamic_cast<ConsumedPrescription*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
1283 #endif
1284 }
1285
1286 ::IceInternal::ProxyHandle<ConsumedPrescription> ice_collocationOptimized(bool __co) const
1287 {
1288 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1289 typedef ::IceProxy::Ice::Object _Base;
1290 return dynamic_cast<ConsumedPrescription*>(_Base::ice_collocationOptimized(__co).get());
1291 #else
1292 return dynamic_cast<ConsumedPrescription*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
1293 #endif
1294 }
1295
1296 ::IceInternal::ProxyHandle<ConsumedPrescription> ice_twoway() const
1297 {
1298 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1299 typedef ::IceProxy::Ice::Object _Base;
1300 return dynamic_cast<ConsumedPrescription*>(_Base::ice_twoway().get());
1301 #else
1302 return dynamic_cast<ConsumedPrescription*>(::IceProxy::Ice::Object::ice_twoway().get());
1303 #endif
1304 }
1305
1306 ::IceInternal::ProxyHandle<ConsumedPrescription> ice_oneway() const
1307 {
1308 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1309 typedef ::IceProxy::Ice::Object _Base;
1310 return dynamic_cast<ConsumedPrescription*>(_Base::ice_oneway().get());
1311 #else
1312 return dynamic_cast<ConsumedPrescription*>(::IceProxy::Ice::Object::ice_oneway().get());
1313 #endif
1314 }
1315
1316 ::IceInternal::ProxyHandle<ConsumedPrescription> ice_batchOneway() const
1317 {
1318 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1319 typedef ::IceProxy::Ice::Object _Base;
1320 return dynamic_cast<ConsumedPrescription*>(_Base::ice_batchOneway().get());
1321 #else
1322 return dynamic_cast<ConsumedPrescription*>(::IceProxy::Ice::Object::ice_batchOneway().get());
1323 #endif
1324 }
1325
1326 ::IceInternal::ProxyHandle<ConsumedPrescription> ice_datagram() const
1327 {
1328 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1329 typedef ::IceProxy::Ice::Object _Base;
1330 return dynamic_cast<ConsumedPrescription*>(_Base::ice_datagram().get());
1331 #else
1332 return dynamic_cast<ConsumedPrescription*>(::IceProxy::Ice::Object::ice_datagram().get());
1333 #endif
1334 }
1335
1336 ::IceInternal::ProxyHandle<ConsumedPrescription> ice_batchDatagram() const
1337 {
1338 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1339 typedef ::IceProxy::Ice::Object _Base;
1340 return dynamic_cast<ConsumedPrescription*>(_Base::ice_batchDatagram().get());
1341 #else
1342 return dynamic_cast<ConsumedPrescription*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
1343 #endif
1344 }
1345
1346 ::IceInternal::ProxyHandle<ConsumedPrescription> ice_compress(bool __compress) const
1347 {
1348 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1349 typedef ::IceProxy::Ice::Object _Base;
1350 return dynamic_cast<ConsumedPrescription*>(_Base::ice_compress(__compress).get());
1351 #else
1352 return dynamic_cast<ConsumedPrescription*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
1353 #endif
1354 }
1355
1356 ::IceInternal::ProxyHandle<ConsumedPrescription> ice_timeout(int __timeout) const
1357 {
1358 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1359 typedef ::IceProxy::Ice::Object _Base;
1360 return dynamic_cast<ConsumedPrescription*>(_Base::ice_timeout(__timeout).get());
1361 #else
1362 return dynamic_cast<ConsumedPrescription*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
1363 #endif
1364 }
1365
1366 ::IceInternal::ProxyHandle<ConsumedPrescription> ice_connectionId(const std::string& __id) const
1367 {
1368 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1369 typedef ::IceProxy::Ice::Object _Base;
1370 return dynamic_cast<ConsumedPrescription*>(_Base::ice_connectionId(__id).get());
1371 #else
1372 return dynamic_cast<ConsumedPrescription*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
1373 #endif
1374 }
1375
1376 static const ::std::string& ice_staticId();
1377
1378private:
1379
1380 virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
1381 virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
1382 virtual ::IceProxy::Ice::Object* __newInstance() const;
1383};
1384
1385class Request : virtual public ::IceProxy::Ice::Object
1386{
1387public:
1388
1389 ::IceInternal::ProxyHandle<Request> ice_context(const ::Ice::Context& __context) const
1390 {
1391 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1392 typedef ::IceProxy::Ice::Object _Base;
1393 return dynamic_cast<Request*>(_Base::ice_context(__context).get());
1394 #else
1395 return dynamic_cast<Request*>(::IceProxy::Ice::Object::ice_context(__context).get());
1396 #endif
1397 }
1398
1399 ::IceInternal::ProxyHandle<Request> ice_adapterId(const std::string& __id) const
1400 {
1401 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1402 typedef ::IceProxy::Ice::Object _Base;
1403 return dynamic_cast<Request*>(_Base::ice_adapterId(__id).get());
1404 #else
1405 return dynamic_cast<Request*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
1406 #endif
1407 }
1408
1409 ::IceInternal::ProxyHandle<Request> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
1410 {
1411 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1412 typedef ::IceProxy::Ice::Object _Base;
1413 return dynamic_cast<Request*>(_Base::ice_endpoints(__endpoints).get());
1414 #else
1415 return dynamic_cast<Request*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
1416 #endif
1417 }
1418
1419 ::IceInternal::ProxyHandle<Request> ice_locatorCacheTimeout(int __timeout) const
1420 {
1421 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1422 typedef ::IceProxy::Ice::Object _Base;
1423 return dynamic_cast<Request*>(_Base::ice_locatorCacheTimeout(__timeout).get());
1424 #else
1425 return dynamic_cast<Request*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
1426 #endif
1427 }
1428
1429 ::IceInternal::ProxyHandle<Request> ice_connectionCached(bool __cached) const
1430 {
1431 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1432 typedef ::IceProxy::Ice::Object _Base;
1433 return dynamic_cast<Request*>(_Base::ice_connectionCached(__cached).get());
1434 #else
1435 return dynamic_cast<Request*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
1436 #endif
1437 }
1438
1439 ::IceInternal::ProxyHandle<Request> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
1440 {
1441 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1442 typedef ::IceProxy::Ice::Object _Base;
1443 return dynamic_cast<Request*>(_Base::ice_endpointSelection(__est).get());
1444 #else
1445 return dynamic_cast<Request*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
1446 #endif
1447 }
1448
1449 ::IceInternal::ProxyHandle<Request> ice_secure(bool __secure) const
1450 {
1451 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1452 typedef ::IceProxy::Ice::Object _Base;
1453 return dynamic_cast<Request*>(_Base::ice_secure(__secure).get());
1454 #else
1455 return dynamic_cast<Request*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
1456 #endif
1457 }
1458
1459 ::IceInternal::ProxyHandle<Request> ice_preferSecure(bool __preferSecure) const
1460 {
1461 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1462 typedef ::IceProxy::Ice::Object _Base;
1463 return dynamic_cast<Request*>(_Base::ice_preferSecure(__preferSecure).get());
1464 #else
1465 return dynamic_cast<Request*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
1466 #endif
1467 }
1468
1469 ::IceInternal::ProxyHandle<Request> ice_router(const ::Ice::RouterPrx& __router) const
1470 {
1471 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1472 typedef ::IceProxy::Ice::Object _Base;
1473 return dynamic_cast<Request*>(_Base::ice_router(__router).get());
1474 #else
1475 return dynamic_cast<Request*>(::IceProxy::Ice::Object::ice_router(__router).get());
1476 #endif
1477 }
1478
1479 ::IceInternal::ProxyHandle<Request> ice_locator(const ::Ice::LocatorPrx& __locator) const
1480 {
1481 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1482 typedef ::IceProxy::Ice::Object _Base;
1483 return dynamic_cast<Request*>(_Base::ice_locator(__locator).get());
1484 #else
1485 return dynamic_cast<Request*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
1486 #endif
1487 }
1488
1489 ::IceInternal::ProxyHandle<Request> ice_collocationOptimized(bool __co) const
1490 {
1491 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1492 typedef ::IceProxy::Ice::Object _Base;
1493 return dynamic_cast<Request*>(_Base::ice_collocationOptimized(__co).get());
1494 #else
1495 return dynamic_cast<Request*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
1496 #endif
1497 }
1498
1499 ::IceInternal::ProxyHandle<Request> ice_twoway() const
1500 {
1501 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1502 typedef ::IceProxy::Ice::Object _Base;
1503 return dynamic_cast<Request*>(_Base::ice_twoway().get());
1504 #else
1505 return dynamic_cast<Request*>(::IceProxy::Ice::Object::ice_twoway().get());
1506 #endif
1507 }
1508
1509 ::IceInternal::ProxyHandle<Request> ice_oneway() const
1510 {
1511 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1512 typedef ::IceProxy::Ice::Object _Base;
1513 return dynamic_cast<Request*>(_Base::ice_oneway().get());
1514 #else
1515 return dynamic_cast<Request*>(::IceProxy::Ice::Object::ice_oneway().get());
1516 #endif
1517 }
1518
1519 ::IceInternal::ProxyHandle<Request> ice_batchOneway() const
1520 {
1521 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1522 typedef ::IceProxy::Ice::Object _Base;
1523 return dynamic_cast<Request*>(_Base::ice_batchOneway().get());
1524 #else
1525 return dynamic_cast<Request*>(::IceProxy::Ice::Object::ice_batchOneway().get());
1526 #endif
1527 }
1528
1529 ::IceInternal::ProxyHandle<Request> ice_datagram() const
1530 {
1531 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1532 typedef ::IceProxy::Ice::Object _Base;
1533 return dynamic_cast<Request*>(_Base::ice_datagram().get());
1534 #else
1535 return dynamic_cast<Request*>(::IceProxy::Ice::Object::ice_datagram().get());
1536 #endif
1537 }
1538
1539 ::IceInternal::ProxyHandle<Request> ice_batchDatagram() const
1540 {
1541 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1542 typedef ::IceProxy::Ice::Object _Base;
1543 return dynamic_cast<Request*>(_Base::ice_batchDatagram().get());
1544 #else
1545 return dynamic_cast<Request*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
1546 #endif
1547 }
1548
1549 ::IceInternal::ProxyHandle<Request> ice_compress(bool __compress) const
1550 {
1551 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1552 typedef ::IceProxy::Ice::Object _Base;
1553 return dynamic_cast<Request*>(_Base::ice_compress(__compress).get());
1554 #else
1555 return dynamic_cast<Request*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
1556 #endif
1557 }
1558
1559 ::IceInternal::ProxyHandle<Request> ice_timeout(int __timeout) const
1560 {
1561 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1562 typedef ::IceProxy::Ice::Object _Base;
1563 return dynamic_cast<Request*>(_Base::ice_timeout(__timeout).get());
1564 #else
1565 return dynamic_cast<Request*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
1566 #endif
1567 }
1568
1569 ::IceInternal::ProxyHandle<Request> ice_connectionId(const std::string& __id) const
1570 {
1571 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1572 typedef ::IceProxy::Ice::Object _Base;
1573 return dynamic_cast<Request*>(_Base::ice_connectionId(__id).get());
1574 #else
1575 return dynamic_cast<Request*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
1576 #endif
1577 }
1578
1579 static const ::std::string& ice_staticId();
1580
1581private:
1582
1583 virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
1584 virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
1585 virtual ::IceProxy::Ice::Object* __newInstance() const;
1586};
1587
1588class ThirdPartyRequest : virtual public ::IceProxy::Ehr::Request
1589{
1590public:
1591
1592 ::IceInternal::ProxyHandle<ThirdPartyRequest> ice_context(const ::Ice::Context& __context) const
1593 {
1594 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1595 typedef ::IceProxy::Ice::Object _Base;
1596 return dynamic_cast<ThirdPartyRequest*>(_Base::ice_context(__context).get());
1597 #else
1598 return dynamic_cast<ThirdPartyRequest*>(::IceProxy::Ice::Object::ice_context(__context).get());
1599 #endif
1600 }
1601
1602 ::IceInternal::ProxyHandle<ThirdPartyRequest> ice_adapterId(const std::string& __id) const
1603 {
1604 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1605 typedef ::IceProxy::Ice::Object _Base;
1606 return dynamic_cast<ThirdPartyRequest*>(_Base::ice_adapterId(__id).get());
1607 #else
1608 return dynamic_cast<ThirdPartyRequest*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
1609 #endif
1610 }
1611
1612 ::IceInternal::ProxyHandle<ThirdPartyRequest> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
1613 {
1614 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1615 typedef ::IceProxy::Ice::Object _Base;
1616 return dynamic_cast<ThirdPartyRequest*>(_Base::ice_endpoints(__endpoints).get());
1617 #else
1618 return dynamic_cast<ThirdPartyRequest*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
1619 #endif
1620 }
1621
1622 ::IceInternal::ProxyHandle<ThirdPartyRequest> ice_locatorCacheTimeout(int __timeout) const
1623 {
1624 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1625 typedef ::IceProxy::Ice::Object _Base;
1626 return dynamic_cast<ThirdPartyRequest*>(_Base::ice_locatorCacheTimeout(__timeout).get());
1627 #else
1628 return dynamic_cast<ThirdPartyRequest*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
1629 #endif
1630 }
1631
1632 ::IceInternal::ProxyHandle<ThirdPartyRequest> ice_connectionCached(bool __cached) const
1633 {
1634 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1635 typedef ::IceProxy::Ice::Object _Base;
1636 return dynamic_cast<ThirdPartyRequest*>(_Base::ice_connectionCached(__cached).get());
1637 #else
1638 return dynamic_cast<ThirdPartyRequest*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
1639 #endif
1640 }
1641
1642 ::IceInternal::ProxyHandle<ThirdPartyRequest> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
1643 {
1644 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1645 typedef ::IceProxy::Ice::Object _Base;
1646 return dynamic_cast<ThirdPartyRequest*>(_Base::ice_endpointSelection(__est).get());
1647 #else
1648 return dynamic_cast<ThirdPartyRequest*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
1649 #endif
1650 }
1651
1652 ::IceInternal::ProxyHandle<ThirdPartyRequest> ice_secure(bool __secure) const
1653 {
1654 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1655 typedef ::IceProxy::Ice::Object _Base;
1656 return dynamic_cast<ThirdPartyRequest*>(_Base::ice_secure(__secure).get());
1657 #else
1658 return dynamic_cast<ThirdPartyRequest*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
1659 #endif
1660 }
1661
1662 ::IceInternal::ProxyHandle<ThirdPartyRequest> ice_preferSecure(bool __preferSecure) const
1663 {
1664 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1665 typedef ::IceProxy::Ice::Object _Base;
1666 return dynamic_cast<ThirdPartyRequest*>(_Base::ice_preferSecure(__preferSecure).get());
1667 #else
1668 return dynamic_cast<ThirdPartyRequest*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
1669 #endif
1670 }
1671
1672 ::IceInternal::ProxyHandle<ThirdPartyRequest> ice_router(const ::Ice::RouterPrx& __router) const
1673 {
1674 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1675 typedef ::IceProxy::Ice::Object _Base;
1676 return dynamic_cast<ThirdPartyRequest*>(_Base::ice_router(__router).get());
1677 #else
1678 return dynamic_cast<ThirdPartyRequest*>(::IceProxy::Ice::Object::ice_router(__router).get());
1679 #endif
1680 }
1681
1682 ::IceInternal::ProxyHandle<ThirdPartyRequest> ice_locator(const ::Ice::LocatorPrx& __locator) const
1683 {
1684 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1685 typedef ::IceProxy::Ice::Object _Base;
1686 return dynamic_cast<ThirdPartyRequest*>(_Base::ice_locator(__locator).get());
1687 #else
1688 return dynamic_cast<ThirdPartyRequest*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
1689 #endif
1690 }
1691
1692 ::IceInternal::ProxyHandle<ThirdPartyRequest> ice_collocationOptimized(bool __co) const
1693 {
1694 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1695 typedef ::IceProxy::Ice::Object _Base;
1696 return dynamic_cast<ThirdPartyRequest*>(_Base::ice_collocationOptimized(__co).get());
1697 #else
1698 return dynamic_cast<ThirdPartyRequest*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
1699 #endif
1700 }
1701
1702 ::IceInternal::ProxyHandle<ThirdPartyRequest> ice_twoway() const
1703 {
1704 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1705 typedef ::IceProxy::Ice::Object _Base;
1706 return dynamic_cast<ThirdPartyRequest*>(_Base::ice_twoway().get());
1707 #else
1708 return dynamic_cast<ThirdPartyRequest*>(::IceProxy::Ice::Object::ice_twoway().get());
1709 #endif
1710 }
1711
1712 ::IceInternal::ProxyHandle<ThirdPartyRequest> ice_oneway() const
1713 {
1714 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1715 typedef ::IceProxy::Ice::Object _Base;
1716 return dynamic_cast<ThirdPartyRequest*>(_Base::ice_oneway().get());
1717 #else
1718 return dynamic_cast<ThirdPartyRequest*>(::IceProxy::Ice::Object::ice_oneway().get());
1719 #endif
1720 }
1721
1722 ::IceInternal::ProxyHandle<ThirdPartyRequest> ice_batchOneway() const
1723 {
1724 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1725 typedef ::IceProxy::Ice::Object _Base;
1726 return dynamic_cast<ThirdPartyRequest*>(_Base::ice_batchOneway().get());
1727 #else
1728 return dynamic_cast<ThirdPartyRequest*>(::IceProxy::Ice::Object::ice_batchOneway().get());
1729 #endif
1730 }
1731
1732 ::IceInternal::ProxyHandle<ThirdPartyRequest> ice_datagram() const
1733 {
1734 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1735 typedef ::IceProxy::Ice::Object _Base;
1736 return dynamic_cast<ThirdPartyRequest*>(_Base::ice_datagram().get());
1737 #else
1738 return dynamic_cast<ThirdPartyRequest*>(::IceProxy::Ice::Object::ice_datagram().get());
1739 #endif
1740 }
1741
1742 ::IceInternal::ProxyHandle<ThirdPartyRequest> ice_batchDatagram() const
1743 {
1744 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1745 typedef ::IceProxy::Ice::Object _Base;
1746 return dynamic_cast<ThirdPartyRequest*>(_Base::ice_batchDatagram().get());
1747 #else
1748 return dynamic_cast<ThirdPartyRequest*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
1749 #endif
1750 }
1751
1752 ::IceInternal::ProxyHandle<ThirdPartyRequest> ice_compress(bool __compress) const
1753 {
1754 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1755 typedef ::IceProxy::Ice::Object _Base;
1756 return dynamic_cast<ThirdPartyRequest*>(_Base::ice_compress(__compress).get());
1757 #else
1758 return dynamic_cast<ThirdPartyRequest*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
1759 #endif
1760 }
1761
1762 ::IceInternal::ProxyHandle<ThirdPartyRequest> ice_timeout(int __timeout) const
1763 {
1764 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1765 typedef ::IceProxy::Ice::Object _Base;
1766 return dynamic_cast<ThirdPartyRequest*>(_Base::ice_timeout(__timeout).get());
1767 #else
1768 return dynamic_cast<ThirdPartyRequest*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
1769 #endif
1770 }
1771
1772 ::IceInternal::ProxyHandle<ThirdPartyRequest> ice_connectionId(const std::string& __id) const
1773 {
1774 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1775 typedef ::IceProxy::Ice::Object _Base;
1776 return dynamic_cast<ThirdPartyRequest*>(_Base::ice_connectionId(__id).get());
1777 #else
1778 return dynamic_cast<ThirdPartyRequest*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
1779 #endif
1780 }
1781
1782 static const ::std::string& ice_staticId();
1783
1784private:
1785
1786 virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
1787 virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
1788 virtual ::IceProxy::Ice::Object* __newInstance() const;
1789};
1790
1791class CreatePrescriptionRequest : virtual public ::IceProxy::Ehr::ThirdPartyRequest
1792{
1793public:
1794
1795 ::IceInternal::ProxyHandle<CreatePrescriptionRequest> ice_context(const ::Ice::Context& __context) const
1796 {
1797 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1798 typedef ::IceProxy::Ice::Object _Base;
1799 return dynamic_cast<CreatePrescriptionRequest*>(_Base::ice_context(__context).get());
1800 #else
1801 return dynamic_cast<CreatePrescriptionRequest*>(::IceProxy::Ice::Object::ice_context(__context).get());
1802 #endif
1803 }
1804
1805 ::IceInternal::ProxyHandle<CreatePrescriptionRequest> ice_adapterId(const std::string& __id) const
1806 {
1807 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1808 typedef ::IceProxy::Ice::Object _Base;
1809 return dynamic_cast<CreatePrescriptionRequest*>(_Base::ice_adapterId(__id).get());
1810 #else
1811 return dynamic_cast<CreatePrescriptionRequest*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
1812 #endif
1813 }
1814
1815 ::IceInternal::ProxyHandle<CreatePrescriptionRequest> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
1816 {
1817 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1818 typedef ::IceProxy::Ice::Object _Base;
1819 return dynamic_cast<CreatePrescriptionRequest*>(_Base::ice_endpoints(__endpoints).get());
1820 #else
1821 return dynamic_cast<CreatePrescriptionRequest*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
1822 #endif
1823 }
1824
1825 ::IceInternal::ProxyHandle<CreatePrescriptionRequest> ice_locatorCacheTimeout(int __timeout) const
1826 {
1827 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1828 typedef ::IceProxy::Ice::Object _Base;
1829 return dynamic_cast<CreatePrescriptionRequest*>(_Base::ice_locatorCacheTimeout(__timeout).get());
1830 #else
1831 return dynamic_cast<CreatePrescriptionRequest*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
1832 #endif
1833 }
1834
1835 ::IceInternal::ProxyHandle<CreatePrescriptionRequest> ice_connectionCached(bool __cached) const
1836 {
1837 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1838 typedef ::IceProxy::Ice::Object _Base;
1839 return dynamic_cast<CreatePrescriptionRequest*>(_Base::ice_connectionCached(__cached).get());
1840 #else
1841 return dynamic_cast<CreatePrescriptionRequest*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
1842 #endif
1843 }
1844
1845 ::IceInternal::ProxyHandle<CreatePrescriptionRequest> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
1846 {
1847 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1848 typedef ::IceProxy::Ice::Object _Base;
1849 return dynamic_cast<CreatePrescriptionRequest*>(_Base::ice_endpointSelection(__est).get());
1850 #else
1851 return dynamic_cast<CreatePrescriptionRequest*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
1852 #endif
1853 }
1854
1855 ::IceInternal::ProxyHandle<CreatePrescriptionRequest> ice_secure(bool __secure) const
1856 {
1857 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1858 typedef ::IceProxy::Ice::Object _Base;
1859 return dynamic_cast<CreatePrescriptionRequest*>(_Base::ice_secure(__secure).get());
1860 #else
1861 return dynamic_cast<CreatePrescriptionRequest*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
1862 #endif
1863 }
1864
1865 ::IceInternal::ProxyHandle<CreatePrescriptionRequest> ice_preferSecure(bool __preferSecure) const
1866 {
1867 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1868 typedef ::IceProxy::Ice::Object _Base;
1869 return dynamic_cast<CreatePrescriptionRequest*>(_Base::ice_preferSecure(__preferSecure).get());
1870 #else
1871 return dynamic_cast<CreatePrescriptionRequest*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
1872 #endif
1873 }
1874
1875 ::IceInternal::ProxyHandle<CreatePrescriptionRequest> ice_router(const ::Ice::RouterPrx& __router) const
1876 {
1877 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1878 typedef ::IceProxy::Ice::Object _Base;
1879 return dynamic_cast<CreatePrescriptionRequest*>(_Base::ice_router(__router).get());
1880 #else
1881 return dynamic_cast<CreatePrescriptionRequest*>(::IceProxy::Ice::Object::ice_router(__router).get());
1882 #endif
1883 }
1884
1885 ::IceInternal::ProxyHandle<CreatePrescriptionRequest> ice_locator(const ::Ice::LocatorPrx& __locator) const
1886 {
1887 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1888 typedef ::IceProxy::Ice::Object _Base;
1889 return dynamic_cast<CreatePrescriptionRequest*>(_Base::ice_locator(__locator).get());
1890 #else
1891 return dynamic_cast<CreatePrescriptionRequest*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
1892 #endif
1893 }
1894
1895 ::IceInternal::ProxyHandle<CreatePrescriptionRequest> ice_collocationOptimized(bool __co) const
1896 {
1897 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1898 typedef ::IceProxy::Ice::Object _Base;
1899 return dynamic_cast<CreatePrescriptionRequest*>(_Base::ice_collocationOptimized(__co).get());
1900 #else
1901 return dynamic_cast<CreatePrescriptionRequest*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
1902 #endif
1903 }
1904
1905 ::IceInternal::ProxyHandle<CreatePrescriptionRequest> ice_twoway() const
1906 {
1907 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1908 typedef ::IceProxy::Ice::Object _Base;
1909 return dynamic_cast<CreatePrescriptionRequest*>(_Base::ice_twoway().get());
1910 #else
1911 return dynamic_cast<CreatePrescriptionRequest*>(::IceProxy::Ice::Object::ice_twoway().get());
1912 #endif
1913 }
1914
1915 ::IceInternal::ProxyHandle<CreatePrescriptionRequest> ice_oneway() const
1916 {
1917 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1918 typedef ::IceProxy::Ice::Object _Base;
1919 return dynamic_cast<CreatePrescriptionRequest*>(_Base::ice_oneway().get());
1920 #else
1921 return dynamic_cast<CreatePrescriptionRequest*>(::IceProxy::Ice::Object::ice_oneway().get());
1922 #endif
1923 }
1924
1925 ::IceInternal::ProxyHandle<CreatePrescriptionRequest> ice_batchOneway() const
1926 {
1927 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1928 typedef ::IceProxy::Ice::Object _Base;
1929 return dynamic_cast<CreatePrescriptionRequest*>(_Base::ice_batchOneway().get());
1930 #else
1931 return dynamic_cast<CreatePrescriptionRequest*>(::IceProxy::Ice::Object::ice_batchOneway().get());
1932 #endif
1933 }
1934
1935 ::IceInternal::ProxyHandle<CreatePrescriptionRequest> ice_datagram() const
1936 {
1937 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1938 typedef ::IceProxy::Ice::Object _Base;
1939 return dynamic_cast<CreatePrescriptionRequest*>(_Base::ice_datagram().get());
1940 #else
1941 return dynamic_cast<CreatePrescriptionRequest*>(::IceProxy::Ice::Object::ice_datagram().get());
1942 #endif
1943 }
1944
1945 ::IceInternal::ProxyHandle<CreatePrescriptionRequest> ice_batchDatagram() const
1946 {
1947 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1948 typedef ::IceProxy::Ice::Object _Base;
1949 return dynamic_cast<CreatePrescriptionRequest*>(_Base::ice_batchDatagram().get());
1950 #else
1951 return dynamic_cast<CreatePrescriptionRequest*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
1952 #endif
1953 }
1954
1955 ::IceInternal::ProxyHandle<CreatePrescriptionRequest> ice_compress(bool __compress) const
1956 {
1957 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1958 typedef ::IceProxy::Ice::Object _Base;
1959 return dynamic_cast<CreatePrescriptionRequest*>(_Base::ice_compress(__compress).get());
1960 #else
1961 return dynamic_cast<CreatePrescriptionRequest*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
1962 #endif
1963 }
1964
1965 ::IceInternal::ProxyHandle<CreatePrescriptionRequest> ice_timeout(int __timeout) const
1966 {
1967 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1968 typedef ::IceProxy::Ice::Object _Base;
1969 return dynamic_cast<CreatePrescriptionRequest*>(_Base::ice_timeout(__timeout).get());
1970 #else
1971 return dynamic_cast<CreatePrescriptionRequest*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
1972 #endif
1973 }
1974
1975 ::IceInternal::ProxyHandle<CreatePrescriptionRequest> ice_connectionId(const std::string& __id) const
1976 {
1977 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
1978 typedef ::IceProxy::Ice::Object _Base;
1979 return dynamic_cast<CreatePrescriptionRequest*>(_Base::ice_connectionId(__id).get());
1980 #else
1981 return dynamic_cast<CreatePrescriptionRequest*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
1982 #endif
1983 }
1984
1985 static const ::std::string& ice_staticId();
1986
1987private:
1988
1989 virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
1990 virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
1991 virtual ::IceProxy::Ice::Object* __newInstance() const;
1992};
1993
1994class ConsumePrescriptionRequest : virtual public ::IceProxy::Ehr::ThirdPartyRequest
1995{
1996public:
1997
1998 ::IceInternal::ProxyHandle<ConsumePrescriptionRequest> ice_context(const ::Ice::Context& __context) const
1999 {
2000 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2001 typedef ::IceProxy::Ice::Object _Base;
2002 return dynamic_cast<ConsumePrescriptionRequest*>(_Base::ice_context(__context).get());
2003 #else
2004 return dynamic_cast<ConsumePrescriptionRequest*>(::IceProxy::Ice::Object::ice_context(__context).get());
2005 #endif
2006 }
2007
2008 ::IceInternal::ProxyHandle<ConsumePrescriptionRequest> ice_adapterId(const std::string& __id) const
2009 {
2010 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2011 typedef ::IceProxy::Ice::Object _Base;
2012 return dynamic_cast<ConsumePrescriptionRequest*>(_Base::ice_adapterId(__id).get());
2013 #else
2014 return dynamic_cast<ConsumePrescriptionRequest*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
2015 #endif
2016 }
2017
2018 ::IceInternal::ProxyHandle<ConsumePrescriptionRequest> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
2019 {
2020 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2021 typedef ::IceProxy::Ice::Object _Base;
2022 return dynamic_cast<ConsumePrescriptionRequest*>(_Base::ice_endpoints(__endpoints).get());
2023 #else
2024 return dynamic_cast<ConsumePrescriptionRequest*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
2025 #endif
2026 }
2027
2028 ::IceInternal::ProxyHandle<ConsumePrescriptionRequest> ice_locatorCacheTimeout(int __timeout) const
2029 {
2030 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2031 typedef ::IceProxy::Ice::Object _Base;
2032 return dynamic_cast<ConsumePrescriptionRequest*>(_Base::ice_locatorCacheTimeout(__timeout).get());
2033 #else
2034 return dynamic_cast<ConsumePrescriptionRequest*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
2035 #endif
2036 }
2037
2038 ::IceInternal::ProxyHandle<ConsumePrescriptionRequest> ice_connectionCached(bool __cached) const
2039 {
2040 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2041 typedef ::IceProxy::Ice::Object _Base;
2042 return dynamic_cast<ConsumePrescriptionRequest*>(_Base::ice_connectionCached(__cached).get());
2043 #else
2044 return dynamic_cast<ConsumePrescriptionRequest*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
2045 #endif
2046 }
2047
2048 ::IceInternal::ProxyHandle<ConsumePrescriptionRequest> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
2049 {
2050 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2051 typedef ::IceProxy::Ice::Object _Base;
2052 return dynamic_cast<ConsumePrescriptionRequest*>(_Base::ice_endpointSelection(__est).get());
2053 #else
2054 return dynamic_cast<ConsumePrescriptionRequest*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
2055 #endif
2056 }
2057
2058 ::IceInternal::ProxyHandle<ConsumePrescriptionRequest> ice_secure(bool __secure) const
2059 {
2060 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2061 typedef ::IceProxy::Ice::Object _Base;
2062 return dynamic_cast<ConsumePrescriptionRequest*>(_Base::ice_secure(__secure).get());
2063 #else
2064 return dynamic_cast<ConsumePrescriptionRequest*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
2065 #endif
2066 }
2067
2068 ::IceInternal::ProxyHandle<ConsumePrescriptionRequest> ice_preferSecure(bool __preferSecure) const
2069 {
2070 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2071 typedef ::IceProxy::Ice::Object _Base;
2072 return dynamic_cast<ConsumePrescriptionRequest*>(_Base::ice_preferSecure(__preferSecure).get());
2073 #else
2074 return dynamic_cast<ConsumePrescriptionRequest*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
2075 #endif
2076 }
2077
2078 ::IceInternal::ProxyHandle<ConsumePrescriptionRequest> ice_router(const ::Ice::RouterPrx& __router) const
2079 {
2080 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2081 typedef ::IceProxy::Ice::Object _Base;
2082 return dynamic_cast<ConsumePrescriptionRequest*>(_Base::ice_router(__router).get());
2083 #else
2084 return dynamic_cast<ConsumePrescriptionRequest*>(::IceProxy::Ice::Object::ice_router(__router).get());
2085 #endif
2086 }
2087
2088 ::IceInternal::ProxyHandle<ConsumePrescriptionRequest> ice_locator(const ::Ice::LocatorPrx& __locator) const
2089 {
2090 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2091 typedef ::IceProxy::Ice::Object _Base;
2092 return dynamic_cast<ConsumePrescriptionRequest*>(_Base::ice_locator(__locator).get());
2093 #else
2094 return dynamic_cast<ConsumePrescriptionRequest*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
2095 #endif
2096 }
2097
2098 ::IceInternal::ProxyHandle<ConsumePrescriptionRequest> ice_collocationOptimized(bool __co) const
2099 {
2100 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2101 typedef ::IceProxy::Ice::Object _Base;
2102 return dynamic_cast<ConsumePrescriptionRequest*>(_Base::ice_collocationOptimized(__co).get());
2103 #else
2104 return dynamic_cast<ConsumePrescriptionRequest*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
2105 #endif
2106 }
2107
2108 ::IceInternal::ProxyHandle<ConsumePrescriptionRequest> ice_twoway() const
2109 {
2110 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2111 typedef ::IceProxy::Ice::Object _Base;
2112 return dynamic_cast<ConsumePrescriptionRequest*>(_Base::ice_twoway().get());
2113 #else
2114 return dynamic_cast<ConsumePrescriptionRequest*>(::IceProxy::Ice::Object::ice_twoway().get());
2115 #endif
2116 }
2117
2118 ::IceInternal::ProxyHandle<ConsumePrescriptionRequest> ice_oneway() const
2119 {
2120 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2121 typedef ::IceProxy::Ice::Object _Base;
2122 return dynamic_cast<ConsumePrescriptionRequest*>(_Base::ice_oneway().get());
2123 #else
2124 return dynamic_cast<ConsumePrescriptionRequest*>(::IceProxy::Ice::Object::ice_oneway().get());
2125 #endif
2126 }
2127
2128 ::IceInternal::ProxyHandle<ConsumePrescriptionRequest> ice_batchOneway() const
2129 {
2130 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2131 typedef ::IceProxy::Ice::Object _Base;
2132 return dynamic_cast<ConsumePrescriptionRequest*>(_Base::ice_batchOneway().get());
2133 #else
2134 return dynamic_cast<ConsumePrescriptionRequest*>(::IceProxy::Ice::Object::ice_batchOneway().get());
2135 #endif
2136 }
2137
2138 ::IceInternal::ProxyHandle<ConsumePrescriptionRequest> ice_datagram() const
2139 {
2140 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2141 typedef ::IceProxy::Ice::Object _Base;
2142 return dynamic_cast<ConsumePrescriptionRequest*>(_Base::ice_datagram().get());
2143 #else
2144 return dynamic_cast<ConsumePrescriptionRequest*>(::IceProxy::Ice::Object::ice_datagram().get());
2145 #endif
2146 }
2147
2148 ::IceInternal::ProxyHandle<ConsumePrescriptionRequest> ice_batchDatagram() const
2149 {
2150 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2151 typedef ::IceProxy::Ice::Object _Base;
2152 return dynamic_cast<ConsumePrescriptionRequest*>(_Base::ice_batchDatagram().get());
2153 #else
2154 return dynamic_cast<ConsumePrescriptionRequest*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
2155 #endif
2156 }
2157
2158 ::IceInternal::ProxyHandle<ConsumePrescriptionRequest> ice_compress(bool __compress) const
2159 {
2160 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2161 typedef ::IceProxy::Ice::Object _Base;
2162 return dynamic_cast<ConsumePrescriptionRequest*>(_Base::ice_compress(__compress).get());
2163 #else
2164 return dynamic_cast<ConsumePrescriptionRequest*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
2165 #endif
2166 }
2167
2168 ::IceInternal::ProxyHandle<ConsumePrescriptionRequest> ice_timeout(int __timeout) const
2169 {
2170 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2171 typedef ::IceProxy::Ice::Object _Base;
2172 return dynamic_cast<ConsumePrescriptionRequest*>(_Base::ice_timeout(__timeout).get());
2173 #else
2174 return dynamic_cast<ConsumePrescriptionRequest*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
2175 #endif
2176 }
2177
2178 ::IceInternal::ProxyHandle<ConsumePrescriptionRequest> ice_connectionId(const std::string& __id) const
2179 {
2180 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2181 typedef ::IceProxy::Ice::Object _Base;
2182 return dynamic_cast<ConsumePrescriptionRequest*>(_Base::ice_connectionId(__id).get());
2183 #else
2184 return dynamic_cast<ConsumePrescriptionRequest*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
2185 #endif
2186 }
2187
2188 static const ::std::string& ice_staticId();
2189
2190private:
2191
2192 virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
2193 virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
2194 virtual ::IceProxy::Ice::Object* __newInstance() const;
2195};
2196
2197class ListDocumentsRequest : virtual public ::IceProxy::Ehr::ThirdPartyRequest
2198{
2199public:
2200
2201 ::IceInternal::ProxyHandle<ListDocumentsRequest> ice_context(const ::Ice::Context& __context) const
2202 {
2203 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2204 typedef ::IceProxy::Ice::Object _Base;
2205 return dynamic_cast<ListDocumentsRequest*>(_Base::ice_context(__context).get());
2206 #else
2207 return dynamic_cast<ListDocumentsRequest*>(::IceProxy::Ice::Object::ice_context(__context).get());
2208 #endif
2209 }
2210
2211 ::IceInternal::ProxyHandle<ListDocumentsRequest> ice_adapterId(const std::string& __id) const
2212 {
2213 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2214 typedef ::IceProxy::Ice::Object _Base;
2215 return dynamic_cast<ListDocumentsRequest*>(_Base::ice_adapterId(__id).get());
2216 #else
2217 return dynamic_cast<ListDocumentsRequest*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
2218 #endif
2219 }
2220
2221 ::IceInternal::ProxyHandle<ListDocumentsRequest> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
2222 {
2223 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2224 typedef ::IceProxy::Ice::Object _Base;
2225 return dynamic_cast<ListDocumentsRequest*>(_Base::ice_endpoints(__endpoints).get());
2226 #else
2227 return dynamic_cast<ListDocumentsRequest*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
2228 #endif
2229 }
2230
2231 ::IceInternal::ProxyHandle<ListDocumentsRequest> ice_locatorCacheTimeout(int __timeout) const
2232 {
2233 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2234 typedef ::IceProxy::Ice::Object _Base;
2235 return dynamic_cast<ListDocumentsRequest*>(_Base::ice_locatorCacheTimeout(__timeout).get());
2236 #else
2237 return dynamic_cast<ListDocumentsRequest*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
2238 #endif
2239 }
2240
2241 ::IceInternal::ProxyHandle<ListDocumentsRequest> ice_connectionCached(bool __cached) const
2242 {
2243 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2244 typedef ::IceProxy::Ice::Object _Base;
2245 return dynamic_cast<ListDocumentsRequest*>(_Base::ice_connectionCached(__cached).get());
2246 #else
2247 return dynamic_cast<ListDocumentsRequest*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
2248 #endif
2249 }
2250
2251 ::IceInternal::ProxyHandle<ListDocumentsRequest> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
2252 {
2253 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2254 typedef ::IceProxy::Ice::Object _Base;
2255 return dynamic_cast<ListDocumentsRequest*>(_Base::ice_endpointSelection(__est).get());
2256 #else
2257 return dynamic_cast<ListDocumentsRequest*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
2258 #endif
2259 }
2260
2261 ::IceInternal::ProxyHandle<ListDocumentsRequest> ice_secure(bool __secure) const
2262 {
2263 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2264 typedef ::IceProxy::Ice::Object _Base;
2265 return dynamic_cast<ListDocumentsRequest*>(_Base::ice_secure(__secure).get());
2266 #else
2267 return dynamic_cast<ListDocumentsRequest*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
2268 #endif
2269 }
2270
2271 ::IceInternal::ProxyHandle<ListDocumentsRequest> ice_preferSecure(bool __preferSecure) const
2272 {
2273 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2274 typedef ::IceProxy::Ice::Object _Base;
2275 return dynamic_cast<ListDocumentsRequest*>(_Base::ice_preferSecure(__preferSecure).get());
2276 #else
2277 return dynamic_cast<ListDocumentsRequest*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
2278 #endif
2279 }
2280
2281 ::IceInternal::ProxyHandle<ListDocumentsRequest> ice_router(const ::Ice::RouterPrx& __router) const
2282 {
2283 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2284 typedef ::IceProxy::Ice::Object _Base;
2285 return dynamic_cast<ListDocumentsRequest*>(_Base::ice_router(__router).get());
2286 #else
2287 return dynamic_cast<ListDocumentsRequest*>(::IceProxy::Ice::Object::ice_router(__router).get());
2288 #endif
2289 }
2290
2291 ::IceInternal::ProxyHandle<ListDocumentsRequest> ice_locator(const ::Ice::LocatorPrx& __locator) const
2292 {
2293 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2294 typedef ::IceProxy::Ice::Object _Base;
2295 return dynamic_cast<ListDocumentsRequest*>(_Base::ice_locator(__locator).get());
2296 #else
2297 return dynamic_cast<ListDocumentsRequest*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
2298 #endif
2299 }
2300
2301 ::IceInternal::ProxyHandle<ListDocumentsRequest> ice_collocationOptimized(bool __co) const
2302 {
2303 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2304 typedef ::IceProxy::Ice::Object _Base;
2305 return dynamic_cast<ListDocumentsRequest*>(_Base::ice_collocationOptimized(__co).get());
2306 #else
2307 return dynamic_cast<ListDocumentsRequest*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
2308 #endif
2309 }
2310
2311 ::IceInternal::ProxyHandle<ListDocumentsRequest> ice_twoway() const
2312 {
2313 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2314 typedef ::IceProxy::Ice::Object _Base;
2315 return dynamic_cast<ListDocumentsRequest*>(_Base::ice_twoway().get());
2316 #else
2317 return dynamic_cast<ListDocumentsRequest*>(::IceProxy::Ice::Object::ice_twoway().get());
2318 #endif
2319 }
2320
2321 ::IceInternal::ProxyHandle<ListDocumentsRequest> ice_oneway() const
2322 {
2323 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2324 typedef ::IceProxy::Ice::Object _Base;
2325 return dynamic_cast<ListDocumentsRequest*>(_Base::ice_oneway().get());
2326 #else
2327 return dynamic_cast<ListDocumentsRequest*>(::IceProxy::Ice::Object::ice_oneway().get());
2328 #endif
2329 }
2330
2331 ::IceInternal::ProxyHandle<ListDocumentsRequest> ice_batchOneway() const
2332 {
2333 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2334 typedef ::IceProxy::Ice::Object _Base;
2335 return dynamic_cast<ListDocumentsRequest*>(_Base::ice_batchOneway().get());
2336 #else
2337 return dynamic_cast<ListDocumentsRequest*>(::IceProxy::Ice::Object::ice_batchOneway().get());
2338 #endif
2339 }
2340
2341 ::IceInternal::ProxyHandle<ListDocumentsRequest> ice_datagram() const
2342 {
2343 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2344 typedef ::IceProxy::Ice::Object _Base;
2345 return dynamic_cast<ListDocumentsRequest*>(_Base::ice_datagram().get());
2346 #else
2347 return dynamic_cast<ListDocumentsRequest*>(::IceProxy::Ice::Object::ice_datagram().get());
2348 #endif
2349 }
2350
2351 ::IceInternal::ProxyHandle<ListDocumentsRequest> ice_batchDatagram() const
2352 {
2353 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2354 typedef ::IceProxy::Ice::Object _Base;
2355 return dynamic_cast<ListDocumentsRequest*>(_Base::ice_batchDatagram().get());
2356 #else
2357 return dynamic_cast<ListDocumentsRequest*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
2358 #endif
2359 }
2360
2361 ::IceInternal::ProxyHandle<ListDocumentsRequest> ice_compress(bool __compress) const
2362 {
2363 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2364 typedef ::IceProxy::Ice::Object _Base;
2365 return dynamic_cast<ListDocumentsRequest*>(_Base::ice_compress(__compress).get());
2366 #else
2367 return dynamic_cast<ListDocumentsRequest*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
2368 #endif
2369 }
2370
2371 ::IceInternal::ProxyHandle<ListDocumentsRequest> ice_timeout(int __timeout) const
2372 {
2373 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2374 typedef ::IceProxy::Ice::Object _Base;
2375 return dynamic_cast<ListDocumentsRequest*>(_Base::ice_timeout(__timeout).get());
2376 #else
2377 return dynamic_cast<ListDocumentsRequest*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
2378 #endif
2379 }
2380
2381 ::IceInternal::ProxyHandle<ListDocumentsRequest> ice_connectionId(const std::string& __id) const
2382 {
2383 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2384 typedef ::IceProxy::Ice::Object _Base;
2385 return dynamic_cast<ListDocumentsRequest*>(_Base::ice_connectionId(__id).get());
2386 #else
2387 return dynamic_cast<ListDocumentsRequest*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
2388 #endif
2389 }
2390
2391 static const ::std::string& ice_staticId();
2392
2393private:
2394
2395 virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
2396 virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
2397 virtual ::IceProxy::Ice::Object* __newInstance() const;
2398};
2399
2400class FindDocumentsRequest : virtual public ::IceProxy::Ehr::ThirdPartyRequest
2401{
2402public:
2403
2404 ::IceInternal::ProxyHandle<FindDocumentsRequest> ice_context(const ::Ice::Context& __context) const
2405 {
2406 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2407 typedef ::IceProxy::Ice::Object _Base;
2408 return dynamic_cast<FindDocumentsRequest*>(_Base::ice_context(__context).get());
2409 #else
2410 return dynamic_cast<FindDocumentsRequest*>(::IceProxy::Ice::Object::ice_context(__context).get());
2411 #endif
2412 }
2413
2414 ::IceInternal::ProxyHandle<FindDocumentsRequest> ice_adapterId(const std::string& __id) const
2415 {
2416 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2417 typedef ::IceProxy::Ice::Object _Base;
2418 return dynamic_cast<FindDocumentsRequest*>(_Base::ice_adapterId(__id).get());
2419 #else
2420 return dynamic_cast<FindDocumentsRequest*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
2421 #endif
2422 }
2423
2424 ::IceInternal::ProxyHandle<FindDocumentsRequest> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
2425 {
2426 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2427 typedef ::IceProxy::Ice::Object _Base;
2428 return dynamic_cast<FindDocumentsRequest*>(_Base::ice_endpoints(__endpoints).get());
2429 #else
2430 return dynamic_cast<FindDocumentsRequest*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
2431 #endif
2432 }
2433
2434 ::IceInternal::ProxyHandle<FindDocumentsRequest> ice_locatorCacheTimeout(int __timeout) const
2435 {
2436 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2437 typedef ::IceProxy::Ice::Object _Base;
2438 return dynamic_cast<FindDocumentsRequest*>(_Base::ice_locatorCacheTimeout(__timeout).get());
2439 #else
2440 return dynamic_cast<FindDocumentsRequest*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
2441 #endif
2442 }
2443
2444 ::IceInternal::ProxyHandle<FindDocumentsRequest> ice_connectionCached(bool __cached) const
2445 {
2446 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2447 typedef ::IceProxy::Ice::Object _Base;
2448 return dynamic_cast<FindDocumentsRequest*>(_Base::ice_connectionCached(__cached).get());
2449 #else
2450 return dynamic_cast<FindDocumentsRequest*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
2451 #endif
2452 }
2453
2454 ::IceInternal::ProxyHandle<FindDocumentsRequest> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
2455 {
2456 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2457 typedef ::IceProxy::Ice::Object _Base;
2458 return dynamic_cast<FindDocumentsRequest*>(_Base::ice_endpointSelection(__est).get());
2459 #else
2460 return dynamic_cast<FindDocumentsRequest*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
2461 #endif
2462 }
2463
2464 ::IceInternal::ProxyHandle<FindDocumentsRequest> ice_secure(bool __secure) const
2465 {
2466 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2467 typedef ::IceProxy::Ice::Object _Base;
2468 return dynamic_cast<FindDocumentsRequest*>(_Base::ice_secure(__secure).get());
2469 #else
2470 return dynamic_cast<FindDocumentsRequest*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
2471 #endif
2472 }
2473
2474 ::IceInternal::ProxyHandle<FindDocumentsRequest> ice_preferSecure(bool __preferSecure) const
2475 {
2476 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2477 typedef ::IceProxy::Ice::Object _Base;
2478 return dynamic_cast<FindDocumentsRequest*>(_Base::ice_preferSecure(__preferSecure).get());
2479 #else
2480 return dynamic_cast<FindDocumentsRequest*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
2481 #endif
2482 }
2483
2484 ::IceInternal::ProxyHandle<FindDocumentsRequest> ice_router(const ::Ice::RouterPrx& __router) const
2485 {
2486 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2487 typedef ::IceProxy::Ice::Object _Base;
2488 return dynamic_cast<FindDocumentsRequest*>(_Base::ice_router(__router).get());
2489 #else
2490 return dynamic_cast<FindDocumentsRequest*>(::IceProxy::Ice::Object::ice_router(__router).get());
2491 #endif
2492 }
2493
2494 ::IceInternal::ProxyHandle<FindDocumentsRequest> ice_locator(const ::Ice::LocatorPrx& __locator) const
2495 {
2496 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2497 typedef ::IceProxy::Ice::Object _Base;
2498 return dynamic_cast<FindDocumentsRequest*>(_Base::ice_locator(__locator).get());
2499 #else
2500 return dynamic_cast<FindDocumentsRequest*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
2501 #endif
2502 }
2503
2504 ::IceInternal::ProxyHandle<FindDocumentsRequest> ice_collocationOptimized(bool __co) const
2505 {
2506 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2507 typedef ::IceProxy::Ice::Object _Base;
2508 return dynamic_cast<FindDocumentsRequest*>(_Base::ice_collocationOptimized(__co).get());
2509 #else
2510 return dynamic_cast<FindDocumentsRequest*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
2511 #endif
2512 }
2513
2514 ::IceInternal::ProxyHandle<FindDocumentsRequest> ice_twoway() const
2515 {
2516 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2517 typedef ::IceProxy::Ice::Object _Base;
2518 return dynamic_cast<FindDocumentsRequest*>(_Base::ice_twoway().get());
2519 #else
2520 return dynamic_cast<FindDocumentsRequest*>(::IceProxy::Ice::Object::ice_twoway().get());
2521 #endif
2522 }
2523
2524 ::IceInternal::ProxyHandle<FindDocumentsRequest> ice_oneway() const
2525 {
2526 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2527 typedef ::IceProxy::Ice::Object _Base;
2528 return dynamic_cast<FindDocumentsRequest*>(_Base::ice_oneway().get());
2529 #else
2530 return dynamic_cast<FindDocumentsRequest*>(::IceProxy::Ice::Object::ice_oneway().get());
2531 #endif
2532 }
2533
2534 ::IceInternal::ProxyHandle<FindDocumentsRequest> ice_batchOneway() const
2535 {
2536 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2537 typedef ::IceProxy::Ice::Object _Base;
2538 return dynamic_cast<FindDocumentsRequest*>(_Base::ice_batchOneway().get());
2539 #else
2540 return dynamic_cast<FindDocumentsRequest*>(::IceProxy::Ice::Object::ice_batchOneway().get());
2541 #endif
2542 }
2543
2544 ::IceInternal::ProxyHandle<FindDocumentsRequest> ice_datagram() const
2545 {
2546 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2547 typedef ::IceProxy::Ice::Object _Base;
2548 return dynamic_cast<FindDocumentsRequest*>(_Base::ice_datagram().get());
2549 #else
2550 return dynamic_cast<FindDocumentsRequest*>(::IceProxy::Ice::Object::ice_datagram().get());
2551 #endif
2552 }
2553
2554 ::IceInternal::ProxyHandle<FindDocumentsRequest> ice_batchDatagram() const
2555 {
2556 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2557 typedef ::IceProxy::Ice::Object _Base;
2558 return dynamic_cast<FindDocumentsRequest*>(_Base::ice_batchDatagram().get());
2559 #else
2560 return dynamic_cast<FindDocumentsRequest*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
2561 #endif
2562 }
2563
2564 ::IceInternal::ProxyHandle<FindDocumentsRequest> ice_compress(bool __compress) const
2565 {
2566 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2567 typedef ::IceProxy::Ice::Object _Base;
2568 return dynamic_cast<FindDocumentsRequest*>(_Base::ice_compress(__compress).get());
2569 #else
2570 return dynamic_cast<FindDocumentsRequest*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
2571 #endif
2572 }
2573
2574 ::IceInternal::ProxyHandle<FindDocumentsRequest> ice_timeout(int __timeout) const
2575 {
2576 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2577 typedef ::IceProxy::Ice::Object _Base;
2578 return dynamic_cast<FindDocumentsRequest*>(_Base::ice_timeout(__timeout).get());
2579 #else
2580 return dynamic_cast<FindDocumentsRequest*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
2581 #endif
2582 }
2583
2584 ::IceInternal::ProxyHandle<FindDocumentsRequest> ice_connectionId(const std::string& __id) const
2585 {
2586 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2587 typedef ::IceProxy::Ice::Object _Base;
2588 return dynamic_cast<FindDocumentsRequest*>(_Base::ice_connectionId(__id).get());
2589 #else
2590 return dynamic_cast<FindDocumentsRequest*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
2591 #endif
2592 }
2593
2594 static const ::std::string& ice_staticId();
2595
2596private:
2597
2598 virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
2599 virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
2600 virtual ::IceProxy::Ice::Object* __newInstance() const;
2601};
2602
2603class CreatePermissionRequest : virtual public ::IceProxy::Ehr::Request
2604{
2605public:
2606
2607 ::IceInternal::ProxyHandle<CreatePermissionRequest> ice_context(const ::Ice::Context& __context) const
2608 {
2609 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2610 typedef ::IceProxy::Ice::Object _Base;
2611 return dynamic_cast<CreatePermissionRequest*>(_Base::ice_context(__context).get());
2612 #else
2613 return dynamic_cast<CreatePermissionRequest*>(::IceProxy::Ice::Object::ice_context(__context).get());
2614 #endif
2615 }
2616
2617 ::IceInternal::ProxyHandle<CreatePermissionRequest> ice_adapterId(const std::string& __id) const
2618 {
2619 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2620 typedef ::IceProxy::Ice::Object _Base;
2621 return dynamic_cast<CreatePermissionRequest*>(_Base::ice_adapterId(__id).get());
2622 #else
2623 return dynamic_cast<CreatePermissionRequest*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
2624 #endif
2625 }
2626
2627 ::IceInternal::ProxyHandle<CreatePermissionRequest> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
2628 {
2629 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2630 typedef ::IceProxy::Ice::Object _Base;
2631 return dynamic_cast<CreatePermissionRequest*>(_Base::ice_endpoints(__endpoints).get());
2632 #else
2633 return dynamic_cast<CreatePermissionRequest*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
2634 #endif
2635 }
2636
2637 ::IceInternal::ProxyHandle<CreatePermissionRequest> ice_locatorCacheTimeout(int __timeout) const
2638 {
2639 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2640 typedef ::IceProxy::Ice::Object _Base;
2641 return dynamic_cast<CreatePermissionRequest*>(_Base::ice_locatorCacheTimeout(__timeout).get());
2642 #else
2643 return dynamic_cast<CreatePermissionRequest*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
2644 #endif
2645 }
2646
2647 ::IceInternal::ProxyHandle<CreatePermissionRequest> ice_connectionCached(bool __cached) const
2648 {
2649 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2650 typedef ::IceProxy::Ice::Object _Base;
2651 return dynamic_cast<CreatePermissionRequest*>(_Base::ice_connectionCached(__cached).get());
2652 #else
2653 return dynamic_cast<CreatePermissionRequest*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
2654 #endif
2655 }
2656
2657 ::IceInternal::ProxyHandle<CreatePermissionRequest> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
2658 {
2659 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2660 typedef ::IceProxy::Ice::Object _Base;
2661 return dynamic_cast<CreatePermissionRequest*>(_Base::ice_endpointSelection(__est).get());
2662 #else
2663 return dynamic_cast<CreatePermissionRequest*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
2664 #endif
2665 }
2666
2667 ::IceInternal::ProxyHandle<CreatePermissionRequest> ice_secure(bool __secure) const
2668 {
2669 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2670 typedef ::IceProxy::Ice::Object _Base;
2671 return dynamic_cast<CreatePermissionRequest*>(_Base::ice_secure(__secure).get());
2672 #else
2673 return dynamic_cast<CreatePermissionRequest*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
2674 #endif
2675 }
2676
2677 ::IceInternal::ProxyHandle<CreatePermissionRequest> ice_preferSecure(bool __preferSecure) const
2678 {
2679 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2680 typedef ::IceProxy::Ice::Object _Base;
2681 return dynamic_cast<CreatePermissionRequest*>(_Base::ice_preferSecure(__preferSecure).get());
2682 #else
2683 return dynamic_cast<CreatePermissionRequest*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
2684 #endif
2685 }
2686
2687 ::IceInternal::ProxyHandle<CreatePermissionRequest> ice_router(const ::Ice::RouterPrx& __router) const
2688 {
2689 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2690 typedef ::IceProxy::Ice::Object _Base;
2691 return dynamic_cast<CreatePermissionRequest*>(_Base::ice_router(__router).get());
2692 #else
2693 return dynamic_cast<CreatePermissionRequest*>(::IceProxy::Ice::Object::ice_router(__router).get());
2694 #endif
2695 }
2696
2697 ::IceInternal::ProxyHandle<CreatePermissionRequest> ice_locator(const ::Ice::LocatorPrx& __locator) const
2698 {
2699 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2700 typedef ::IceProxy::Ice::Object _Base;
2701 return dynamic_cast<CreatePermissionRequest*>(_Base::ice_locator(__locator).get());
2702 #else
2703 return dynamic_cast<CreatePermissionRequest*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
2704 #endif
2705 }
2706
2707 ::IceInternal::ProxyHandle<CreatePermissionRequest> ice_collocationOptimized(bool __co) const
2708 {
2709 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2710 typedef ::IceProxy::Ice::Object _Base;
2711 return dynamic_cast<CreatePermissionRequest*>(_Base::ice_collocationOptimized(__co).get());
2712 #else
2713 return dynamic_cast<CreatePermissionRequest*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
2714 #endif
2715 }
2716
2717 ::IceInternal::ProxyHandle<CreatePermissionRequest> ice_twoway() const
2718 {
2719 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2720 typedef ::IceProxy::Ice::Object _Base;
2721 return dynamic_cast<CreatePermissionRequest*>(_Base::ice_twoway().get());
2722 #else
2723 return dynamic_cast<CreatePermissionRequest*>(::IceProxy::Ice::Object::ice_twoway().get());
2724 #endif
2725 }
2726
2727 ::IceInternal::ProxyHandle<CreatePermissionRequest> ice_oneway() const
2728 {
2729 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2730 typedef ::IceProxy::Ice::Object _Base;
2731 return dynamic_cast<CreatePermissionRequest*>(_Base::ice_oneway().get());
2732 #else
2733 return dynamic_cast<CreatePermissionRequest*>(::IceProxy::Ice::Object::ice_oneway().get());
2734 #endif
2735 }
2736
2737 ::IceInternal::ProxyHandle<CreatePermissionRequest> ice_batchOneway() const
2738 {
2739 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2740 typedef ::IceProxy::Ice::Object _Base;
2741 return dynamic_cast<CreatePermissionRequest*>(_Base::ice_batchOneway().get());
2742 #else
2743 return dynamic_cast<CreatePermissionRequest*>(::IceProxy::Ice::Object::ice_batchOneway().get());
2744 #endif
2745 }
2746
2747 ::IceInternal::ProxyHandle<CreatePermissionRequest> ice_datagram() const
2748 {
2749 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2750 typedef ::IceProxy::Ice::Object _Base;
2751 return dynamic_cast<CreatePermissionRequest*>(_Base::ice_datagram().get());
2752 #else
2753 return dynamic_cast<CreatePermissionRequest*>(::IceProxy::Ice::Object::ice_datagram().get());
2754 #endif
2755 }
2756
2757 ::IceInternal::ProxyHandle<CreatePermissionRequest> ice_batchDatagram() const
2758 {
2759 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2760 typedef ::IceProxy::Ice::Object _Base;
2761 return dynamic_cast<CreatePermissionRequest*>(_Base::ice_batchDatagram().get());
2762 #else
2763 return dynamic_cast<CreatePermissionRequest*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
2764 #endif
2765 }
2766
2767 ::IceInternal::ProxyHandle<CreatePermissionRequest> ice_compress(bool __compress) const
2768 {
2769 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2770 typedef ::IceProxy::Ice::Object _Base;
2771 return dynamic_cast<CreatePermissionRequest*>(_Base::ice_compress(__compress).get());
2772 #else
2773 return dynamic_cast<CreatePermissionRequest*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
2774 #endif
2775 }
2776
2777 ::IceInternal::ProxyHandle<CreatePermissionRequest> ice_timeout(int __timeout) const
2778 {
2779 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2780 typedef ::IceProxy::Ice::Object _Base;
2781 return dynamic_cast<CreatePermissionRequest*>(_Base::ice_timeout(__timeout).get());
2782 #else
2783 return dynamic_cast<CreatePermissionRequest*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
2784 #endif
2785 }
2786
2787 ::IceInternal::ProxyHandle<CreatePermissionRequest> ice_connectionId(const std::string& __id) const
2788 {
2789 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2790 typedef ::IceProxy::Ice::Object _Base;
2791 return dynamic_cast<CreatePermissionRequest*>(_Base::ice_connectionId(__id).get());
2792 #else
2793 return dynamic_cast<CreatePermissionRequest*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
2794 #endif
2795 }
2796
2797 static const ::std::string& ice_staticId();
2798
2799private:
2800
2801 virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
2802 virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
2803 virtual ::IceProxy::Ice::Object* __newInstance() const;
2804};
2805
2806class SetDefaultAccessRequest : virtual public ::IceProxy::Ehr::Request
2807{
2808public:
2809
2810 ::IceInternal::ProxyHandle<SetDefaultAccessRequest> ice_context(const ::Ice::Context& __context) const
2811 {
2812 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2813 typedef ::IceProxy::Ice::Object _Base;
2814 return dynamic_cast<SetDefaultAccessRequest*>(_Base::ice_context(__context).get());
2815 #else
2816 return dynamic_cast<SetDefaultAccessRequest*>(::IceProxy::Ice::Object::ice_context(__context).get());
2817 #endif
2818 }
2819
2820 ::IceInternal::ProxyHandle<SetDefaultAccessRequest> ice_adapterId(const std::string& __id) const
2821 {
2822 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2823 typedef ::IceProxy::Ice::Object _Base;
2824 return dynamic_cast<SetDefaultAccessRequest*>(_Base::ice_adapterId(__id).get());
2825 #else
2826 return dynamic_cast<SetDefaultAccessRequest*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
2827 #endif
2828 }
2829
2830 ::IceInternal::ProxyHandle<SetDefaultAccessRequest> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
2831 {
2832 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2833 typedef ::IceProxy::Ice::Object _Base;
2834 return dynamic_cast<SetDefaultAccessRequest*>(_Base::ice_endpoints(__endpoints).get());
2835 #else
2836 return dynamic_cast<SetDefaultAccessRequest*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
2837 #endif
2838 }
2839
2840 ::IceInternal::ProxyHandle<SetDefaultAccessRequest> ice_locatorCacheTimeout(int __timeout) const
2841 {
2842 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2843 typedef ::IceProxy::Ice::Object _Base;
2844 return dynamic_cast<SetDefaultAccessRequest*>(_Base::ice_locatorCacheTimeout(__timeout).get());
2845 #else
2846 return dynamic_cast<SetDefaultAccessRequest*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
2847 #endif
2848 }
2849
2850 ::IceInternal::ProxyHandle<SetDefaultAccessRequest> ice_connectionCached(bool __cached) const
2851 {
2852 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2853 typedef ::IceProxy::Ice::Object _Base;
2854 return dynamic_cast<SetDefaultAccessRequest*>(_Base::ice_connectionCached(__cached).get());
2855 #else
2856 return dynamic_cast<SetDefaultAccessRequest*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
2857 #endif
2858 }
2859
2860 ::IceInternal::ProxyHandle<SetDefaultAccessRequest> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
2861 {
2862 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2863 typedef ::IceProxy::Ice::Object _Base;
2864 return dynamic_cast<SetDefaultAccessRequest*>(_Base::ice_endpointSelection(__est).get());
2865 #else
2866 return dynamic_cast<SetDefaultAccessRequest*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
2867 #endif
2868 }
2869
2870 ::IceInternal::ProxyHandle<SetDefaultAccessRequest> ice_secure(bool __secure) const
2871 {
2872 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2873 typedef ::IceProxy::Ice::Object _Base;
2874 return dynamic_cast<SetDefaultAccessRequest*>(_Base::ice_secure(__secure).get());
2875 #else
2876 return dynamic_cast<SetDefaultAccessRequest*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
2877 #endif
2878 }
2879
2880 ::IceInternal::ProxyHandle<SetDefaultAccessRequest> ice_preferSecure(bool __preferSecure) const
2881 {
2882 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2883 typedef ::IceProxy::Ice::Object _Base;
2884 return dynamic_cast<SetDefaultAccessRequest*>(_Base::ice_preferSecure(__preferSecure).get());
2885 #else
2886 return dynamic_cast<SetDefaultAccessRequest*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
2887 #endif
2888 }
2889
2890 ::IceInternal::ProxyHandle<SetDefaultAccessRequest> ice_router(const ::Ice::RouterPrx& __router) const
2891 {
2892 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2893 typedef ::IceProxy::Ice::Object _Base;
2894 return dynamic_cast<SetDefaultAccessRequest*>(_Base::ice_router(__router).get());
2895 #else
2896 return dynamic_cast<SetDefaultAccessRequest*>(::IceProxy::Ice::Object::ice_router(__router).get());
2897 #endif
2898 }
2899
2900 ::IceInternal::ProxyHandle<SetDefaultAccessRequest> ice_locator(const ::Ice::LocatorPrx& __locator) const
2901 {
2902 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2903 typedef ::IceProxy::Ice::Object _Base;
2904 return dynamic_cast<SetDefaultAccessRequest*>(_Base::ice_locator(__locator).get());
2905 #else
2906 return dynamic_cast<SetDefaultAccessRequest*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
2907 #endif
2908 }
2909
2910 ::IceInternal::ProxyHandle<SetDefaultAccessRequest> ice_collocationOptimized(bool __co) const
2911 {
2912 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2913 typedef ::IceProxy::Ice::Object _Base;
2914 return dynamic_cast<SetDefaultAccessRequest*>(_Base::ice_collocationOptimized(__co).get());
2915 #else
2916 return dynamic_cast<SetDefaultAccessRequest*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
2917 #endif
2918 }
2919
2920 ::IceInternal::ProxyHandle<SetDefaultAccessRequest> ice_twoway() const
2921 {
2922 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2923 typedef ::IceProxy::Ice::Object _Base;
2924 return dynamic_cast<SetDefaultAccessRequest*>(_Base::ice_twoway().get());
2925 #else
2926 return dynamic_cast<SetDefaultAccessRequest*>(::IceProxy::Ice::Object::ice_twoway().get());
2927 #endif
2928 }
2929
2930 ::IceInternal::ProxyHandle<SetDefaultAccessRequest> ice_oneway() const
2931 {
2932 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2933 typedef ::IceProxy::Ice::Object _Base;
2934 return dynamic_cast<SetDefaultAccessRequest*>(_Base::ice_oneway().get());
2935 #else
2936 return dynamic_cast<SetDefaultAccessRequest*>(::IceProxy::Ice::Object::ice_oneway().get());
2937 #endif
2938 }
2939
2940 ::IceInternal::ProxyHandle<SetDefaultAccessRequest> ice_batchOneway() const
2941 {
2942 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2943 typedef ::IceProxy::Ice::Object _Base;
2944 return dynamic_cast<SetDefaultAccessRequest*>(_Base::ice_batchOneway().get());
2945 #else
2946 return dynamic_cast<SetDefaultAccessRequest*>(::IceProxy::Ice::Object::ice_batchOneway().get());
2947 #endif
2948 }
2949
2950 ::IceInternal::ProxyHandle<SetDefaultAccessRequest> ice_datagram() const
2951 {
2952 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2953 typedef ::IceProxy::Ice::Object _Base;
2954 return dynamic_cast<SetDefaultAccessRequest*>(_Base::ice_datagram().get());
2955 #else
2956 return dynamic_cast<SetDefaultAccessRequest*>(::IceProxy::Ice::Object::ice_datagram().get());
2957 #endif
2958 }
2959
2960 ::IceInternal::ProxyHandle<SetDefaultAccessRequest> ice_batchDatagram() const
2961 {
2962 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2963 typedef ::IceProxy::Ice::Object _Base;
2964 return dynamic_cast<SetDefaultAccessRequest*>(_Base::ice_batchDatagram().get());
2965 #else
2966 return dynamic_cast<SetDefaultAccessRequest*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
2967 #endif
2968 }
2969
2970 ::IceInternal::ProxyHandle<SetDefaultAccessRequest> ice_compress(bool __compress) const
2971 {
2972 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2973 typedef ::IceProxy::Ice::Object _Base;
2974 return dynamic_cast<SetDefaultAccessRequest*>(_Base::ice_compress(__compress).get());
2975 #else
2976 return dynamic_cast<SetDefaultAccessRequest*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
2977 #endif
2978 }
2979
2980 ::IceInternal::ProxyHandle<SetDefaultAccessRequest> ice_timeout(int __timeout) const
2981 {
2982 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2983 typedef ::IceProxy::Ice::Object _Base;
2984 return dynamic_cast<SetDefaultAccessRequest*>(_Base::ice_timeout(__timeout).get());
2985 #else
2986 return dynamic_cast<SetDefaultAccessRequest*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
2987 #endif
2988 }
2989
2990 ::IceInternal::ProxyHandle<SetDefaultAccessRequest> ice_connectionId(const std::string& __id) const
2991 {
2992 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
2993 typedef ::IceProxy::Ice::Object _Base;
2994 return dynamic_cast<SetDefaultAccessRequest*>(_Base::ice_connectionId(__id).get());
2995 #else
2996 return dynamic_cast<SetDefaultAccessRequest*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
2997 #endif
2998 }
2999
3000 static const ::std::string& ice_staticId();
3001
3002private:
3003
3004 virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
3005 virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
3006 virtual ::IceProxy::Ice::Object* __newInstance() const;
3007};
3008
3009class ListPermissionsRequest : virtual public ::IceProxy::Ehr::Request
3010{
3011public:
3012
3013 ::IceInternal::ProxyHandle<ListPermissionsRequest> ice_context(const ::Ice::Context& __context) const
3014 {
3015 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3016 typedef ::IceProxy::Ice::Object _Base;
3017 return dynamic_cast<ListPermissionsRequest*>(_Base::ice_context(__context).get());
3018 #else
3019 return dynamic_cast<ListPermissionsRequest*>(::IceProxy::Ice::Object::ice_context(__context).get());
3020 #endif
3021 }
3022
3023 ::IceInternal::ProxyHandle<ListPermissionsRequest> ice_adapterId(const std::string& __id) const
3024 {
3025 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3026 typedef ::IceProxy::Ice::Object _Base;
3027 return dynamic_cast<ListPermissionsRequest*>(_Base::ice_adapterId(__id).get());
3028 #else
3029 return dynamic_cast<ListPermissionsRequest*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
3030 #endif
3031 }
3032
3033 ::IceInternal::ProxyHandle<ListPermissionsRequest> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
3034 {
3035 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3036 typedef ::IceProxy::Ice::Object _Base;
3037 return dynamic_cast<ListPermissionsRequest*>(_Base::ice_endpoints(__endpoints).get());
3038 #else
3039 return dynamic_cast<ListPermissionsRequest*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
3040 #endif
3041 }
3042
3043 ::IceInternal::ProxyHandle<ListPermissionsRequest> ice_locatorCacheTimeout(int __timeout) const
3044 {
3045 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3046 typedef ::IceProxy::Ice::Object _Base;
3047 return dynamic_cast<ListPermissionsRequest*>(_Base::ice_locatorCacheTimeout(__timeout).get());
3048 #else
3049 return dynamic_cast<ListPermissionsRequest*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
3050 #endif
3051 }
3052
3053 ::IceInternal::ProxyHandle<ListPermissionsRequest> ice_connectionCached(bool __cached) const
3054 {
3055 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3056 typedef ::IceProxy::Ice::Object _Base;
3057 return dynamic_cast<ListPermissionsRequest*>(_Base::ice_connectionCached(__cached).get());
3058 #else
3059 return dynamic_cast<ListPermissionsRequest*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
3060 #endif
3061 }
3062
3063 ::IceInternal::ProxyHandle<ListPermissionsRequest> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
3064 {
3065 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3066 typedef ::IceProxy::Ice::Object _Base;
3067 return dynamic_cast<ListPermissionsRequest*>(_Base::ice_endpointSelection(__est).get());
3068 #else
3069 return dynamic_cast<ListPermissionsRequest*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
3070 #endif
3071 }
3072
3073 ::IceInternal::ProxyHandle<ListPermissionsRequest> ice_secure(bool __secure) const
3074 {
3075 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3076 typedef ::IceProxy::Ice::Object _Base;
3077 return dynamic_cast<ListPermissionsRequest*>(_Base::ice_secure(__secure).get());
3078 #else
3079 return dynamic_cast<ListPermissionsRequest*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
3080 #endif
3081 }
3082
3083 ::IceInternal::ProxyHandle<ListPermissionsRequest> ice_preferSecure(bool __preferSecure) const
3084 {
3085 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3086 typedef ::IceProxy::Ice::Object _Base;
3087 return dynamic_cast<ListPermissionsRequest*>(_Base::ice_preferSecure(__preferSecure).get());
3088 #else
3089 return dynamic_cast<ListPermissionsRequest*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
3090 #endif
3091 }
3092
3093 ::IceInternal::ProxyHandle<ListPermissionsRequest> ice_router(const ::Ice::RouterPrx& __router) const
3094 {
3095 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3096 typedef ::IceProxy::Ice::Object _Base;
3097 return dynamic_cast<ListPermissionsRequest*>(_Base::ice_router(__router).get());
3098 #else
3099 return dynamic_cast<ListPermissionsRequest*>(::IceProxy::Ice::Object::ice_router(__router).get());
3100 #endif
3101 }
3102
3103 ::IceInternal::ProxyHandle<ListPermissionsRequest> ice_locator(const ::Ice::LocatorPrx& __locator) const
3104 {
3105 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3106 typedef ::IceProxy::Ice::Object _Base;
3107 return dynamic_cast<ListPermissionsRequest*>(_Base::ice_locator(__locator).get());
3108 #else
3109 return dynamic_cast<ListPermissionsRequest*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
3110 #endif
3111 }
3112
3113 ::IceInternal::ProxyHandle<ListPermissionsRequest> ice_collocationOptimized(bool __co) const
3114 {
3115 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3116 typedef ::IceProxy::Ice::Object _Base;
3117 return dynamic_cast<ListPermissionsRequest*>(_Base::ice_collocationOptimized(__co).get());
3118 #else
3119 return dynamic_cast<ListPermissionsRequest*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
3120 #endif
3121 }
3122
3123 ::IceInternal::ProxyHandle<ListPermissionsRequest> ice_twoway() const
3124 {
3125 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3126 typedef ::IceProxy::Ice::Object _Base;
3127 return dynamic_cast<ListPermissionsRequest*>(_Base::ice_twoway().get());
3128 #else
3129 return dynamic_cast<ListPermissionsRequest*>(::IceProxy::Ice::Object::ice_twoway().get());
3130 #endif
3131 }
3132
3133 ::IceInternal::ProxyHandle<ListPermissionsRequest> ice_oneway() const
3134 {
3135 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3136 typedef ::IceProxy::Ice::Object _Base;
3137 return dynamic_cast<ListPermissionsRequest*>(_Base::ice_oneway().get());
3138 #else
3139 return dynamic_cast<ListPermissionsRequest*>(::IceProxy::Ice::Object::ice_oneway().get());
3140 #endif
3141 }
3142
3143 ::IceInternal::ProxyHandle<ListPermissionsRequest> ice_batchOneway() const
3144 {
3145 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3146 typedef ::IceProxy::Ice::Object _Base;
3147 return dynamic_cast<ListPermissionsRequest*>(_Base::ice_batchOneway().get());
3148 #else
3149 return dynamic_cast<ListPermissionsRequest*>(::IceProxy::Ice::Object::ice_batchOneway().get());
3150 #endif
3151 }
3152
3153 ::IceInternal::ProxyHandle<ListPermissionsRequest> ice_datagram() const
3154 {
3155 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3156 typedef ::IceProxy::Ice::Object _Base;
3157 return dynamic_cast<ListPermissionsRequest*>(_Base::ice_datagram().get());
3158 #else
3159 return dynamic_cast<ListPermissionsRequest*>(::IceProxy::Ice::Object::ice_datagram().get());
3160 #endif
3161 }
3162
3163 ::IceInternal::ProxyHandle<ListPermissionsRequest> ice_batchDatagram() const
3164 {
3165 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3166 typedef ::IceProxy::Ice::Object _Base;
3167 return dynamic_cast<ListPermissionsRequest*>(_Base::ice_batchDatagram().get());
3168 #else
3169 return dynamic_cast<ListPermissionsRequest*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
3170 #endif
3171 }
3172
3173 ::IceInternal::ProxyHandle<ListPermissionsRequest> ice_compress(bool __compress) const
3174 {
3175 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3176 typedef ::IceProxy::Ice::Object _Base;
3177 return dynamic_cast<ListPermissionsRequest*>(_Base::ice_compress(__compress).get());
3178 #else
3179 return dynamic_cast<ListPermissionsRequest*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
3180 #endif
3181 }
3182
3183 ::IceInternal::ProxyHandle<ListPermissionsRequest> ice_timeout(int __timeout) const
3184 {
3185 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3186 typedef ::IceProxy::Ice::Object _Base;
3187 return dynamic_cast<ListPermissionsRequest*>(_Base::ice_timeout(__timeout).get());
3188 #else
3189 return dynamic_cast<ListPermissionsRequest*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
3190 #endif
3191 }
3192
3193 ::IceInternal::ProxyHandle<ListPermissionsRequest> ice_connectionId(const std::string& __id) const
3194 {
3195 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3196 typedef ::IceProxy::Ice::Object _Base;
3197 return dynamic_cast<ListPermissionsRequest*>(_Base::ice_connectionId(__id).get());
3198 #else
3199 return dynamic_cast<ListPermissionsRequest*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
3200 #endif
3201 }
3202
3203 static const ::std::string& ice_staticId();
3204
3205private:
3206
3207 virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
3208 virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
3209 virtual ::IceProxy::Ice::Object* __newInstance() const;
3210};
3211
3212class RemovePermissionRequest : virtual public ::IceProxy::Ehr::Request
3213{
3214public:
3215
3216 ::IceInternal::ProxyHandle<RemovePermissionRequest> ice_context(const ::Ice::Context& __context) const
3217 {
3218 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3219 typedef ::IceProxy::Ice::Object _Base;
3220 return dynamic_cast<RemovePermissionRequest*>(_Base::ice_context(__context).get());
3221 #else
3222 return dynamic_cast<RemovePermissionRequest*>(::IceProxy::Ice::Object::ice_context(__context).get());
3223 #endif
3224 }
3225
3226 ::IceInternal::ProxyHandle<RemovePermissionRequest> ice_adapterId(const std::string& __id) const
3227 {
3228 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3229 typedef ::IceProxy::Ice::Object _Base;
3230 return dynamic_cast<RemovePermissionRequest*>(_Base::ice_adapterId(__id).get());
3231 #else
3232 return dynamic_cast<RemovePermissionRequest*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
3233 #endif
3234 }
3235
3236 ::IceInternal::ProxyHandle<RemovePermissionRequest> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
3237 {
3238 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3239 typedef ::IceProxy::Ice::Object _Base;
3240 return dynamic_cast<RemovePermissionRequest*>(_Base::ice_endpoints(__endpoints).get());
3241 #else
3242 return dynamic_cast<RemovePermissionRequest*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
3243 #endif
3244 }
3245
3246 ::IceInternal::ProxyHandle<RemovePermissionRequest> ice_locatorCacheTimeout(int __timeout) const
3247 {
3248 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3249 typedef ::IceProxy::Ice::Object _Base;
3250 return dynamic_cast<RemovePermissionRequest*>(_Base::ice_locatorCacheTimeout(__timeout).get());
3251 #else
3252 return dynamic_cast<RemovePermissionRequest*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
3253 #endif
3254 }
3255
3256 ::IceInternal::ProxyHandle<RemovePermissionRequest> ice_connectionCached(bool __cached) const
3257 {
3258 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3259 typedef ::IceProxy::Ice::Object _Base;
3260 return dynamic_cast<RemovePermissionRequest*>(_Base::ice_connectionCached(__cached).get());
3261 #else
3262 return dynamic_cast<RemovePermissionRequest*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
3263 #endif
3264 }
3265
3266 ::IceInternal::ProxyHandle<RemovePermissionRequest> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
3267 {
3268 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3269 typedef ::IceProxy::Ice::Object _Base;
3270 return dynamic_cast<RemovePermissionRequest*>(_Base::ice_endpointSelection(__est).get());
3271 #else
3272 return dynamic_cast<RemovePermissionRequest*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
3273 #endif
3274 }
3275
3276 ::IceInternal::ProxyHandle<RemovePermissionRequest> ice_secure(bool __secure) const
3277 {
3278 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3279 typedef ::IceProxy::Ice::Object _Base;
3280 return dynamic_cast<RemovePermissionRequest*>(_Base::ice_secure(__secure).get());
3281 #else
3282 return dynamic_cast<RemovePermissionRequest*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
3283 #endif
3284 }
3285
3286 ::IceInternal::ProxyHandle<RemovePermissionRequest> ice_preferSecure(bool __preferSecure) const
3287 {
3288 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3289 typedef ::IceProxy::Ice::Object _Base;
3290 return dynamic_cast<RemovePermissionRequest*>(_Base::ice_preferSecure(__preferSecure).get());
3291 #else
3292 return dynamic_cast<RemovePermissionRequest*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
3293 #endif
3294 }
3295
3296 ::IceInternal::ProxyHandle<RemovePermissionRequest> ice_router(const ::Ice::RouterPrx& __router) const
3297 {
3298 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3299 typedef ::IceProxy::Ice::Object _Base;
3300 return dynamic_cast<RemovePermissionRequest*>(_Base::ice_router(__router).get());
3301 #else
3302 return dynamic_cast<RemovePermissionRequest*>(::IceProxy::Ice::Object::ice_router(__router).get());
3303 #endif
3304 }
3305
3306 ::IceInternal::ProxyHandle<RemovePermissionRequest> ice_locator(const ::Ice::LocatorPrx& __locator) const
3307 {
3308 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3309 typedef ::IceProxy::Ice::Object _Base;
3310 return dynamic_cast<RemovePermissionRequest*>(_Base::ice_locator(__locator).get());
3311 #else
3312 return dynamic_cast<RemovePermissionRequest*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
3313 #endif
3314 }
3315
3316 ::IceInternal::ProxyHandle<RemovePermissionRequest> ice_collocationOptimized(bool __co) const
3317 {
3318 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3319 typedef ::IceProxy::Ice::Object _Base;
3320 return dynamic_cast<RemovePermissionRequest*>(_Base::ice_collocationOptimized(__co).get());
3321 #else
3322 return dynamic_cast<RemovePermissionRequest*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
3323 #endif
3324 }
3325
3326 ::IceInternal::ProxyHandle<RemovePermissionRequest> ice_twoway() const
3327 {
3328 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3329 typedef ::IceProxy::Ice::Object _Base;
3330 return dynamic_cast<RemovePermissionRequest*>(_Base::ice_twoway().get());
3331 #else
3332 return dynamic_cast<RemovePermissionRequest*>(::IceProxy::Ice::Object::ice_twoway().get());
3333 #endif
3334 }
3335
3336 ::IceInternal::ProxyHandle<RemovePermissionRequest> ice_oneway() const
3337 {
3338 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3339 typedef ::IceProxy::Ice::Object _Base;
3340 return dynamic_cast<RemovePermissionRequest*>(_Base::ice_oneway().get());
3341 #else
3342 return dynamic_cast<RemovePermissionRequest*>(::IceProxy::Ice::Object::ice_oneway().get());
3343 #endif
3344 }
3345
3346 ::IceInternal::ProxyHandle<RemovePermissionRequest> ice_batchOneway() const
3347 {
3348 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3349 typedef ::IceProxy::Ice::Object _Base;
3350 return dynamic_cast<RemovePermissionRequest*>(_Base::ice_batchOneway().get());
3351 #else
3352 return dynamic_cast<RemovePermissionRequest*>(::IceProxy::Ice::Object::ice_batchOneway().get());
3353 #endif
3354 }
3355
3356 ::IceInternal::ProxyHandle<RemovePermissionRequest> ice_datagram() const
3357 {
3358 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3359 typedef ::IceProxy::Ice::Object _Base;
3360 return dynamic_cast<RemovePermissionRequest*>(_Base::ice_datagram().get());
3361 #else
3362 return dynamic_cast<RemovePermissionRequest*>(::IceProxy::Ice::Object::ice_datagram().get());
3363 #endif
3364 }
3365
3366 ::IceInternal::ProxyHandle<RemovePermissionRequest> ice_batchDatagram() const
3367 {
3368 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3369 typedef ::IceProxy::Ice::Object _Base;
3370 return dynamic_cast<RemovePermissionRequest*>(_Base::ice_batchDatagram().get());
3371 #else
3372 return dynamic_cast<RemovePermissionRequest*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
3373 #endif
3374 }
3375
3376 ::IceInternal::ProxyHandle<RemovePermissionRequest> ice_compress(bool __compress) const
3377 {
3378 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3379 typedef ::IceProxy::Ice::Object _Base;
3380 return dynamic_cast<RemovePermissionRequest*>(_Base::ice_compress(__compress).get());
3381 #else
3382 return dynamic_cast<RemovePermissionRequest*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
3383 #endif
3384 }
3385
3386 ::IceInternal::ProxyHandle<RemovePermissionRequest> ice_timeout(int __timeout) const
3387 {
3388 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3389 typedef ::IceProxy::Ice::Object _Base;
3390 return dynamic_cast<RemovePermissionRequest*>(_Base::ice_timeout(__timeout).get());
3391 #else
3392 return dynamic_cast<RemovePermissionRequest*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
3393 #endif
3394 }
3395
3396 ::IceInternal::ProxyHandle<RemovePermissionRequest> ice_connectionId(const std::string& __id) const
3397 {
3398 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3399 typedef ::IceProxy::Ice::Object _Base;
3400 return dynamic_cast<RemovePermissionRequest*>(_Base::ice_connectionId(__id).get());
3401 #else
3402 return dynamic_cast<RemovePermissionRequest*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
3403 #endif
3404 }
3405
3406 static const ::std::string& ice_staticId();
3407
3408private:
3409
3410 virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
3411 virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
3412 virtual ::IceProxy::Ice::Object* __newInstance() const;
3413};
3414
3415class Provider : virtual public ::IceProxy::Ice::Object
3416{
3417public:
3418
3419 void createPrescription(const ::Ehr::CreatePrescriptionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature)
3420 {
3421 createPrescription(request, requestorSignature, ownerSignature, 0);
3422 }
3423 void createPrescription(const ::Ehr::CreatePrescriptionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Context& __ctx)
3424 {
3425 createPrescription(request, requestorSignature, ownerSignature, &__ctx);
3426 }
3427
3428private:
3429
3430 void createPrescription(const ::Ehr::CreatePrescriptionRequestPtr&, const ::Ehr::Signature&, const ::Ehr::Signature&, const ::Ice::Context*);
3431
3432public:
3433
3434 void consumePrescription(const ::Ehr::ConsumePrescriptionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature)
3435 {
3436 consumePrescription(request, requestorSignature, ownerSignature, 0);
3437 }
3438 void consumePrescription(const ::Ehr::ConsumePrescriptionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Context& __ctx)
3439 {
3440 consumePrescription(request, requestorSignature, ownerSignature, &__ctx);
3441 }
3442
3443private:
3444
3445 void consumePrescription(const ::Ehr::ConsumePrescriptionRequestPtr&, const ::Ehr::Signature&, const ::Ehr::Signature&, const ::Ice::Context*);
3446
3447public:
3448
3449 ::Ehr::DocumentList listDocuments(const ::Ehr::ListDocumentsRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature)
3450 {
3451 return listDocuments(request, requestorSignature, ownerSignature, 0);
3452 }
3453 ::Ehr::DocumentList listDocuments(const ::Ehr::ListDocumentsRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Context& __ctx)
3454 {
3455 return listDocuments(request, requestorSignature, ownerSignature, &__ctx);
3456 }
3457
3458private:
3459
3460 ::Ehr::DocumentList listDocuments(const ::Ehr::ListDocumentsRequestPtr&, const ::Ehr::Signature&, const ::Ehr::Signature&, const ::Ice::Context*);
3461
3462public:
3463
3464 ::Ehr::DocumentList findDocuments(const ::Ehr::FindDocumentsRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature)
3465 {
3466 return findDocuments(request, requestorSignature, ownerSignature, 0);
3467 }
3468 ::Ehr::DocumentList findDocuments(const ::Ehr::FindDocumentsRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ehr::Signature& ownerSignature, const ::Ice::Context& __ctx)
3469 {
3470 return findDocuments(request, requestorSignature, ownerSignature, &__ctx);
3471 }
3472
3473private:
3474
3475 ::Ehr::DocumentList findDocuments(const ::Ehr::FindDocumentsRequestPtr&, const ::Ehr::Signature&, const ::Ehr::Signature&, const ::Ice::Context*);
3476
3477public:
3478
3479 void setDefaultAccess(const ::Ehr::SetDefaultAccessRequestPtr& request, const ::Ehr::Signature& requestorSignature)
3480 {
3481 setDefaultAccess(request, requestorSignature, 0);
3482 }
3483 void setDefaultAccess(const ::Ehr::SetDefaultAccessRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Context& __ctx)
3484 {
3485 setDefaultAccess(request, requestorSignature, &__ctx);
3486 }
3487
3488private:
3489
3490 void setDefaultAccess(const ::Ehr::SetDefaultAccessRequestPtr&, const ::Ehr::Signature&, const ::Ice::Context*);
3491
3492public:
3493
3494 void createPermission(const ::Ehr::CreatePermissionRequestPtr& request, const ::Ehr::Signature& requestorSignature)
3495 {
3496 createPermission(request, requestorSignature, 0);
3497 }
3498 void createPermission(const ::Ehr::CreatePermissionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Context& __ctx)
3499 {
3500 createPermission(request, requestorSignature, &__ctx);
3501 }
3502
3503private:
3504
3505 void createPermission(const ::Ehr::CreatePermissionRequestPtr&, const ::Ehr::Signature&, const ::Ice::Context*);
3506
3507public:
3508
3509 ::Ehr::Permissions listPermissions(const ::Ehr::ListPermissionsRequestPtr& request, const ::Ehr::Signature& requestorSignature)
3510 {
3511 return listPermissions(request, requestorSignature, 0);
3512 }
3513 ::Ehr::Permissions listPermissions(const ::Ehr::ListPermissionsRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Context& __ctx)
3514 {
3515 return listPermissions(request, requestorSignature, &__ctx);
3516 }
3517
3518private:
3519
3520 ::Ehr::Permissions listPermissions(const ::Ehr::ListPermissionsRequestPtr&, const ::Ehr::Signature&, const ::Ice::Context*);
3521
3522public:
3523
3524 void removePermission(const ::Ehr::RemovePermissionRequestPtr& request, const ::Ehr::Signature& requestorSignature)
3525 {
3526 removePermission(request, requestorSignature, 0);
3527 }
3528 void removePermission(const ::Ehr::RemovePermissionRequestPtr& request, const ::Ehr::Signature& requestorSignature, const ::Ice::Context& __ctx)
3529 {
3530 removePermission(request, requestorSignature, &__ctx);
3531 }
3532
3533private:
3534
3535 void removePermission(const ::Ehr::RemovePermissionRequestPtr&, const ::Ehr::Signature&, const ::Ice::Context*);
3536
3537public:
3538
3539 ::IceInternal::ProxyHandle<Provider> ice_context(const ::Ice::Context& __context) const
3540 {
3541 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3542 typedef ::IceProxy::Ice::Object _Base;
3543 return dynamic_cast<Provider*>(_Base::ice_context(__context).get());
3544 #else
3545 return dynamic_cast<Provider*>(::IceProxy::Ice::Object::ice_context(__context).get());
3546 #endif
3547 }
3548
3549 ::IceInternal::ProxyHandle<Provider> ice_adapterId(const std::string& __id) const
3550 {
3551 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3552 typedef ::IceProxy::Ice::Object _Base;
3553 return dynamic_cast<Provider*>(_Base::ice_adapterId(__id).get());
3554 #else
3555 return dynamic_cast<Provider*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
3556 #endif
3557 }
3558
3559 ::IceInternal::ProxyHandle<Provider> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
3560 {
3561 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3562 typedef ::IceProxy::Ice::Object _Base;
3563 return dynamic_cast<Provider*>(_Base::ice_endpoints(__endpoints).get());
3564 #else
3565 return dynamic_cast<Provider*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
3566 #endif
3567 }
3568
3569 ::IceInternal::ProxyHandle<Provider> ice_locatorCacheTimeout(int __timeout) const
3570 {
3571 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3572 typedef ::IceProxy::Ice::Object _Base;
3573 return dynamic_cast<Provider*>(_Base::ice_locatorCacheTimeout(__timeout).get());
3574 #else
3575 return dynamic_cast<Provider*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
3576 #endif
3577 }
3578
3579 ::IceInternal::ProxyHandle<Provider> ice_connectionCached(bool __cached) const
3580 {
3581 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3582 typedef ::IceProxy::Ice::Object _Base;
3583 return dynamic_cast<Provider*>(_Base::ice_connectionCached(__cached).get());
3584 #else
3585 return dynamic_cast<Provider*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
3586 #endif
3587 }
3588
3589 ::IceInternal::ProxyHandle<Provider> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
3590 {
3591 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3592 typedef ::IceProxy::Ice::Object _Base;
3593 return dynamic_cast<Provider*>(_Base::ice_endpointSelection(__est).get());
3594 #else
3595 return dynamic_cast<Provider*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
3596 #endif
3597 }
3598
3599 ::IceInternal::ProxyHandle<Provider> ice_secure(bool __secure) const
3600 {
3601 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3602 typedef ::IceProxy::Ice::Object _Base;
3603 return dynamic_cast<Provider*>(_Base::ice_secure(__secure).get());
3604 #else
3605 return dynamic_cast<Provider*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
3606 #endif
3607 }
3608
3609 ::IceInternal::ProxyHandle<Provider> ice_preferSecure(bool __preferSecure) const
3610 {
3611 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3612 typedef ::IceProxy::Ice::Object _Base;
3613 return dynamic_cast<Provider*>(_Base::ice_preferSecure(__preferSecure).get());
3614 #else
3615 return dynamic_cast<Provider*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
3616 #endif
3617 }
3618
3619 ::IceInternal::ProxyHandle<Provider> ice_router(const ::Ice::RouterPrx& __router) const
3620 {
3621 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3622 typedef ::IceProxy::Ice::Object _Base;
3623 return dynamic_cast<Provider*>(_Base::ice_router(__router).get());
3624 #else
3625 return dynamic_cast<Provider*>(::IceProxy::Ice::Object::ice_router(__router).get());
3626 #endif
3627 }
3628
3629 ::IceInternal::ProxyHandle<Provider> ice_locator(const ::Ice::LocatorPrx& __locator) const
3630 {
3631 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3632 typedef ::IceProxy::Ice::Object _Base;
3633 return dynamic_cast<Provider*>(_Base::ice_locator(__locator).get());
3634 #else
3635 return dynamic_cast<Provider*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
3636 #endif
3637 }
3638
3639 ::IceInternal::ProxyHandle<Provider> ice_collocationOptimized(bool __co) const
3640 {
3641 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3642 typedef ::IceProxy::Ice::Object _Base;
3643 return dynamic_cast<Provider*>(_Base::ice_collocationOptimized(__co).get());
3644 #else
3645 return dynamic_cast<Provider*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
3646 #endif
3647 }
3648
3649 ::IceInternal::ProxyHandle<Provider> ice_twoway() const
3650 {
3651 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3652 typedef ::IceProxy::Ice::Object _Base;
3653 return dynamic_cast<Provider*>(_Base::ice_twoway().get());
3654 #else
3655 return dynamic_cast<Provider*>(::IceProxy::Ice::Object::ice_twoway().get());
3656 #endif
3657 }
3658
3659 ::IceInternal::ProxyHandle<Provider> ice_oneway() const
3660 {
3661 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3662 typedef ::IceProxy::Ice::Object _Base;
3663 return dynamic_cast<Provider*>(_Base::ice_oneway().get());
3664 #else
3665 return dynamic_cast<Provider*>(::IceProxy::Ice::Object::ice_oneway().get());
3666 #endif
3667 }
3668
3669 ::IceInternal::ProxyHandle<Provider> ice_batchOneway() const
3670 {
3671 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3672 typedef ::IceProxy::Ice::Object _Base;
3673 return dynamic_cast<Provider*>(_Base::ice_batchOneway().get());
3674 #else
3675 return dynamic_cast<Provider*>(::IceProxy::Ice::Object::ice_batchOneway().get());
3676 #endif
3677 }
3678
3679 ::IceInternal::ProxyHandle<Provider> ice_datagram() const
3680 {
3681 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3682 typedef ::IceProxy::Ice::Object _Base;
3683 return dynamic_cast<Provider*>(_Base::ice_datagram().get());
3684 #else
3685 return dynamic_cast<Provider*>(::IceProxy::Ice::Object::ice_datagram().get());
3686 #endif
3687 }
3688
3689 ::IceInternal::ProxyHandle<Provider> ice_batchDatagram() const
3690 {
3691 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3692 typedef ::IceProxy::Ice::Object _Base;
3693 return dynamic_cast<Provider*>(_Base::ice_batchDatagram().get());
3694 #else
3695 return dynamic_cast<Provider*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
3696 #endif
3697 }
3698
3699 ::IceInternal::ProxyHandle<Provider> ice_compress(bool __compress) const
3700 {
3701 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3702 typedef ::IceProxy::Ice::Object _Base;
3703 return dynamic_cast<Provider*>(_Base::ice_compress(__compress).get());
3704 #else
3705 return dynamic_cast<Provider*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
3706 #endif
3707 }
3708
3709 ::IceInternal::ProxyHandle<Provider> ice_timeout(int __timeout) const
3710 {
3711 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3712 typedef ::IceProxy::Ice::Object _Base;
3713 return dynamic_cast<Provider*>(_Base::ice_timeout(__timeout).get());
3714 #else
3715 return dynamic_cast<Provider*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
3716 #endif
3717 }
3718
3719 ::IceInternal::ProxyHandle<Provider> ice_connectionId(const std::string& __id) const
3720 {
3721 #if defined(_MSC_VER) && (_MSC_VER < 1300) // VC++ 6 compiler bug
3722 typedef ::IceProxy::Ice::Object _Base;
3723 return dynamic_cast<Provider*>(_Base::ice_connectionId(__id).get());
3724 #else
3725 return dynamic_cast<Provider*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
3726 #endif
3727 }
3728
3729 static const ::std::string& ice_staticId();
3730
3731private:
3732
3733 virtual ::IceInternal::Handle< ::IceDelegateM::Ice::Object> __createDelegateM();
3734 virtual ::IceInternal::Handle< ::IceDelegateD::Ice::Object> __createDelegateD();
3735 virtual ::IceProxy::Ice::Object* __newInstance() const;
3736};
3737
3738}
3739
3740}
3741
3742namespace IceDelegate
3743{
3744
3745namespace Ehr
3746{
3747
3748class Document : virtual public ::IceDelegate::Ice::Object
3749{
3750public:
3751};
3752
3753class Prescription : virtual public ::IceDelegate::Ehr::Document
3754{
3755public:
3756};
3757
3758class ConsumedPrescription : virtual public ::IceDelegate::Ehr::Prescription
3759{
3760public:
3761};
3762
3763class Request : virtual public ::IceDelegate::Ice::Object
3764{
3765public:
3766};
3767
3768class ThirdPartyRequest : virtual public ::IceDelegate::Ehr::Request
3769{
3770public:
3771};
3772
3773class CreatePrescriptionRequest : virtual public ::IceDelegate::Ehr::ThirdPartyRequest
3774{
3775public:
3776};
3777
3778class ConsumePrescriptionRequest : virtual public ::IceDelegate::Ehr::ThirdPartyRequest
3779{
3780public:
3781};
3782
3783class ListDocumentsRequest : virtual public ::IceDelegate::Ehr::ThirdPartyRequest
3784{
3785public:
3786};
3787
3788class FindDocumentsRequest : virtual public ::IceDelegate::Ehr::ThirdPartyRequest
3789{
3790public:
3791};
3792
3793class CreatePermissionRequest : virtual public ::IceDelegate::Ehr::Request
3794{
3795public:
3796};
3797
3798class SetDefaultAccessRequest : virtual public ::IceDelegate::Ehr::Request
3799{
3800public:
3801};
3802
3803class ListPermissionsRequest : virtual public ::IceDelegate::Ehr::Request
3804{
3805public:
3806};
3807
3808class RemovePermissionRequest : virtual public ::IceDelegate::Ehr::Request
3809{
3810public:
3811};
3812
3813class Provider : virtual public ::IceDelegate::Ice::Object
3814{
3815public:
3816
3817 virtual void createPrescription(const ::Ehr::CreatePrescriptionRequestPtr&, const ::Ehr::Signature&, const ::Ehr::Signature&, const ::Ice::Context*) = 0;
3818
3819 virtual void consumePrescription(const ::Ehr::ConsumePrescriptionRequestPtr&, const ::Ehr::Signature&, const ::Ehr::Signature&, const ::Ice::Context*) = 0;
3820
3821 virtual ::Ehr::DocumentList listDocuments(const ::Ehr::ListDocumentsRequestPtr&, const ::Ehr::Signature&, const ::Ehr::Signature&, const ::Ice::Context*) = 0;
3822
3823 virtual ::Ehr::DocumentList findDocuments(const ::Ehr::FindDocumentsRequestPtr&, const ::Ehr::Signature&, const ::Ehr::Signature&, const ::Ice::Context*) = 0;
3824
3825 virtual void setDefaultAccess(const ::Ehr::SetDefaultAccessRequestPtr&, const ::Ehr::Signature&, const ::Ice::Context*) = 0;
3826
3827 virtual void createPermission(const ::Ehr::CreatePermissionRequestPtr&, const ::Ehr::Signature&, const ::Ice::Context*) = 0;
3828
3829 virtual ::Ehr::Permissions listPermissions(const ::Ehr::ListPermissionsRequestPtr&, const ::Ehr::Signature&, const ::Ice::Context*) = 0;
3830
3831 virtual void removePermission(const ::Ehr::RemovePermissionRequestPtr&, const ::Ehr::Signature&, const ::Ice::Context*) = 0;
3832};
3833
3834}
3835
3836}
3837
3838namespace IceDelegateM
3839{
3840
3841namespace Ehr
3842{
3843
3844class Document : virtual public ::IceDelegate::Ehr::Document,
3845 virtual public ::IceDelegateM::Ice::Object
3846{
3847public:
3848};
3849
3850class Prescription : virtual public ::IceDelegate::Ehr::Prescription,
3851 virtual public ::IceDelegateM::Ehr::Document
3852{
3853public:
3854};
3855
3856class ConsumedPrescription : virtual public ::IceDelegate::Ehr::ConsumedPrescription,
3857 virtual public ::IceDelegateM::Ehr::Prescription
3858{
3859public:
3860};
3861
3862class Request : virtual public ::IceDelegate::Ehr::Request,
3863 virtual public ::IceDelegateM::Ice::Object
3864{
3865public:
3866};
3867
3868class ThirdPartyRequest : virtual public ::IceDelegate::Ehr::ThirdPartyRequest,
3869 virtual public ::IceDelegateM::Ehr::Request
3870{
3871public:
3872};
3873
3874class CreatePrescriptionRequest : virtual public ::IceDelegate::Ehr::CreatePrescriptionRequest,
3875 virtual public ::IceDelegateM::Ehr::ThirdPartyRequest
3876{
3877public:
3878};
3879
3880class ConsumePrescriptionRequest : virtual public ::IceDelegate::Ehr::ConsumePrescriptionRequest,
3881 virtual public ::IceDelegateM::Ehr::ThirdPartyRequest
3882{
3883public:
3884};
3885
3886class ListDocumentsRequest : virtual public ::IceDelegate::Ehr::ListDocumentsRequest,
3887 virtual public ::IceDelegateM::Ehr::ThirdPartyRequest
3888{
3889public:
3890};
3891
3892class FindDocumentsRequest : virtual public ::IceDelegate::Ehr::FindDocumentsRequest,
3893 virtual public ::IceDelegateM::Ehr::ThirdPartyRequest
3894{
3895public:
3896};
3897
3898class CreatePermissionRequest : virtual public ::IceDelegate::Ehr::CreatePermissionRequest,
3899 virtual public ::IceDelegateM::Ehr::Request
3900{
3901public:
3902};
3903
3904class SetDefaultAccessRequest : virtual public ::IceDelegate::Ehr::SetDefaultAccessRequest,
3905 virtual public ::IceDelegateM::Ehr::Request
3906{
3907public:
3908};
3909
3910class ListPermissionsRequest : virtual public ::IceDelegate::Ehr::ListPermissionsRequest,
3911 virtual public ::IceDelegateM::Ehr::Request
3912{
3913public:
3914};
3915
3916class RemovePermissionRequest : virtual public ::IceDelegate::Ehr::RemovePermissionRequest,
3917 virtual public ::IceDelegateM::Ehr::Request
3918{
3919public:
3920};
3921
3922class Provider : virtual public ::IceDelegate::Ehr::Provider,
3923 virtual public ::IceDelegateM::Ice::Object
3924{
3925public:
3926
3927 virtual void createPrescription(const ::Ehr::CreatePrescriptionRequestPtr&, const ::Ehr::Signature&, const ::Ehr::Signature&, const ::Ice::Context*);
3928
3929 virtual void consumePrescription(const ::Ehr::ConsumePrescriptionRequestPtr&, const ::Ehr::Signature&, const ::Ehr::Signature&, const ::Ice::Context*);
3930
3931 virtual ::Ehr::DocumentList listDocuments(const ::Ehr::ListDocumentsRequestPtr&, const ::Ehr::Signature&, const ::Ehr::Signature&, const ::Ice::Context*);
3932
3933 virtual ::Ehr::DocumentList findDocuments(const ::Ehr::FindDocumentsRequestPtr&, const ::Ehr::Signature&, const ::Ehr::Signature&, const ::Ice::Context*);
3934
3935 virtual void setDefaultAccess(const ::Ehr::SetDefaultAccessRequestPtr&, const ::Ehr::Signature&, const ::Ice::Context*);
3936
3937 virtual void createPermission(const ::Ehr::CreatePermissionRequestPtr&, const ::Ehr::Signature&, const ::Ice::Context*);
3938
3939 virtual ::Ehr::Permissions listPermissions(const ::Ehr::ListPermissionsRequestPtr&, const ::Ehr::Signature&, const ::Ice::Context*);
3940
3941 virtual void removePermission(const ::Ehr::RemovePermissionRequestPtr&, const ::Ehr::Signature&, const ::Ice::Context*);
3942};
3943
3944}
3945
3946}
3947
3948namespace IceDelegateD
3949{
3950
3951namespace Ehr
3952{
3953
3954class Document : virtual public ::IceDelegate::Ehr::Document,
3955 virtual public ::IceDelegateD::Ice::Object
3956{
3957public:
3958};
3959
3960class Prescription : virtual public ::IceDelegate::Ehr::Prescription,
3961 virtual public ::IceDelegateD::Ehr::Document
3962{
3963public:
3964};
3965
3966class ConsumedPrescription : virtual public ::IceDelegate::Ehr::ConsumedPrescription,
3967 virtual public ::IceDelegateD::Ehr::Prescription
3968{
3969public:
3970};
3971
3972class Request : virtual public ::IceDelegate::Ehr::Request,
3973 virtual public ::IceDelegateD::Ice::Object
3974{
3975public:
3976};
3977
3978class ThirdPartyRequest : virtual public ::IceDelegate::Ehr::ThirdPartyRequest,
3979 virtual public ::IceDelegateD::Ehr::Request
3980{
3981public:
3982};
3983
3984class CreatePrescriptionRequest : virtual public ::IceDelegate::Ehr::CreatePrescriptionRequest,
3985 virtual public ::IceDelegateD::Ehr::ThirdPartyRequest
3986{
3987public:
3988};
3989
3990class ConsumePrescriptionRequest : virtual public ::IceDelegate::Ehr::ConsumePrescriptionRequest,
3991 virtual public ::IceDelegateD::Ehr::ThirdPartyRequest
3992{
3993public:
3994};
3995
3996class ListDocumentsRequest : virtual public ::IceDelegate::Ehr::ListDocumentsRequest,
3997 virtual public ::IceDelegateD::Ehr::ThirdPartyRequest
3998{
3999public:
4000};
4001
4002class FindDocumentsRequest : virtual public ::IceDelegate::Ehr::FindDocumentsRequest,
4003 virtual public ::IceDelegateD::Ehr::ThirdPartyRequest
4004{
4005public:
4006};
4007
4008class CreatePermissionRequest : virtual public ::IceDelegate::Ehr::CreatePermissionRequest,
4009 virtual public ::IceDelegateD::Ehr::Request
4010{
4011public:
4012};
4013
4014class SetDefaultAccessRequest : virtual public ::IceDelegate::Ehr::SetDefaultAccessRequest,
4015 virtual public ::IceDelegateD::Ehr::Request
4016{
4017public:
4018};
4019
4020class ListPermissionsRequest : virtual public ::IceDelegate::Ehr::ListPermissionsRequest,
4021 virtual public ::IceDelegateD::Ehr::Request
4022{
4023public:
4024};
4025
4026class RemovePermissionRequest : virtual public ::IceDelegate::Ehr::RemovePermissionRequest,
4027 virtual public ::IceDelegateD::Ehr::Request
4028{
4029public:
4030};
4031
4032class Provider : virtual public ::IceDelegate::Ehr::Provider,
4033 virtual public ::IceDelegateD::Ice::Object
4034{
4035public:
4036
4037 virtual void createPrescription(const ::Ehr::CreatePrescriptionRequestPtr&, const ::Ehr::Signature&, const ::Ehr::Signature&, const ::Ice::Context*);
4038
4039 virtual void consumePrescription(const ::Ehr::ConsumePrescriptionRequestPtr&, const ::Ehr::Signature&, const ::Ehr::Signature&, const ::Ice::Context*);
4040
4041 virtual ::Ehr::DocumentList listDocuments(const ::Ehr::ListDocumentsRequestPtr&, const ::Ehr::Signature&, const ::Ehr::Signature&, const ::Ice::Context*);
4042
4043 virtual ::Ehr::DocumentList findDocuments(const ::Ehr::FindDocumentsRequestPtr&, const ::Ehr::Signature&, const ::Ehr::Signature&, const ::Ice::Context*);
4044
4045 virtual void setDefaultAccess(const ::Ehr::SetDefaultAccessRequestPtr&, const ::Ehr::Signature&, const ::Ice::Context*);
4046
4047 virtual void createPermission(const ::Ehr::CreatePermissionRequestPtr&, const ::Ehr::Signature&, const ::Ice::Context*);
4048
4049 virtual ::Ehr::Permissions listPermissions(const ::Ehr::ListPermissionsRequestPtr&, const ::Ehr::Signature&, const ::Ice::Context*);
4050
4051 virtual void removePermission(const ::Ehr::RemovePermissionRequestPtr&, const ::Ehr::Signature&, const ::Ice::Context*);
4052};
4053
4054}
4055
4056}
4057
4058namespace Ehr
4059{
4060
4061class Document : virtual public ::Ice::Object
4062{
4063public:
4064
4065 typedef DocumentPrx ProxyType;
4066 typedef DocumentPtr PointerType;
4067
4068 Document() {}
4069 explicit Document(::Ehr::DocumentType);
4070 virtual ::Ice::ObjectPtr ice_clone() const;
4071
4072 virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
4073 virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
4074 virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
4075 static const ::std::string& ice_staticId();
4076
4077
4078 virtual void __write(::IceInternal::BasicStream*) const;
4079 virtual void __read(::IceInternal::BasicStream*, bool);
4080 virtual void __write(const ::Ice::OutputStreamPtr&) const;
4081 virtual void __read(const ::Ice::InputStreamPtr&, bool);
4082
4083 static const ::Ice::ObjectFactoryPtr& ice_factory();
4084
4085protected:
4086
4087 virtual ~Document() {}
4088
4089 friend class Document__staticInit;
4090
4091public:
4092
4093 ::Ehr::DocumentType type;
4094};
4095
4096class Document__staticInit
4097{
4098public:
4099
4100 ::Ehr::Document _init;
4101};
4102
4103static Document__staticInit _Document_init;
4104
4105class Prescription : virtual public ::Ehr::Document
4106{
4107public:
4108
4109 typedef PrescriptionPrx ProxyType;
4110 typedef PrescriptionPtr PointerType;
4111
4112 Prescription() {}
4113 Prescription(::Ehr::DocumentType, const ::std::string&, const ::std::string&, const ::std::string&, const ::Ehr::Date&, const ::std::string&, const ::Ehr::Date&, const ::std::string&, const ::std::string&, ::Ice::Int, const ::std::string&, const ::Ehr::Date&, const ::Ehr::Date&);
4114 virtual ::Ice::ObjectPtr ice_clone() const;
4115
4116 virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
4117 virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
4118 virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
4119 static const ::std::string& ice_staticId();
4120
4121
4122 virtual void __write(::IceInternal::BasicStream*) const;
4123 virtual void __read(::IceInternal::BasicStream*, bool);
4124 virtual void __write(const ::Ice::OutputStreamPtr&) const;
4125 virtual void __read(const ::Ice::InputStreamPtr&, bool);
4126
4127 static const ::Ice::ObjectFactoryPtr& ice_factory();
4128
4129protected:
4130
4131 virtual ~Prescription() {}
4132
4133public:
4134
4135 ::std::string originatorName;
4136
4137 ::std::string originatorProfession;
4138
4139 ::std::string originatorAddress;
4140
4141 ::Ehr::Date creationDate;
4142
4143 ::std::string consumerName;
4144
4145 ::Ehr::Date consumerDateOfBirth;
4146
4147 ::std::string drugDescription;
4148
4149 ::std::string form;
4150
4151 ::Ice::Int dosage;
4152
4153 ::std::string measuringUnit;
4154
4155 ::Ehr::Date validFrom;
4156
4157 ::Ehr::Date expires;
4158};
4159
4160class ConsumedPrescription : virtual public ::Ehr::Prescription
4161{
4162public:
4163
4164 typedef ConsumedPrescriptionPrx ProxyType;
4165 typedef ConsumedPrescriptionPtr PointerType;
4166
4167 ConsumedPrescription() {}
4168 ConsumedPrescription(::Ehr::DocumentType, const ::std::string&, const ::std::string&, const ::std::string&, const ::Ehr::Date&, const ::std::string&, const ::Ehr::Date&, const ::std::string&, const ::std::string&, ::Ice::Int, const ::std::string&, const ::Ehr::Date&, const ::Ehr::Date&, const ::std::string&, const ::std::string&, const ::std::string&, const ::Ehr::Date&);
4169 virtual ::Ice::ObjectPtr ice_clone() const;
4170
4171 virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
4172 virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
4173 virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
4174 static const ::std::string& ice_staticId();
4175
4176
4177 virtual void __write(::IceInternal::BasicStream*) const;
4178 virtual void __read(::IceInternal::BasicStream*, bool);
4179 virtual void __write(const ::Ice::OutputStreamPtr&) const;
4180 virtual void __read(const ::Ice::InputStreamPtr&, bool);
4181
4182 static const ::Ice::ObjectFactoryPtr& ice_factory();
4183
4184protected:
4185
4186 virtual ~ConsumedPrescription() {}
4187
4188public:
4189
4190 ::std::string dispenserName;
4191
4192 ::std::string dispenserProfession;
4193
4194 ::std::string dispenserAddress;
4195
4196 ::Ehr::Date dispensingDate;
4197};
4198
4199class Request : virtual public ::Ice::Object
4200{
4201public:
4202
4203 typedef RequestPrx ProxyType;
4204 typedef RequestPtr PointerType;
4205
4206 Request() {}
4207 Request(const ::Ehr::AccountIdentifier&, const ::Ehr::Timestamp&);
4208 virtual ::Ice::ObjectPtr ice_clone() const;
4209
4210 virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
4211 virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
4212 virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
4213 static const ::std::string& ice_staticId();
4214
4215
4216 virtual void __write(::IceInternal::BasicStream*) const;
4217 virtual void __read(::IceInternal::BasicStream*, bool);
4218 virtual void __write(const ::Ice::OutputStreamPtr&) const;
4219 virtual void __read(const ::Ice::InputStreamPtr&, bool);
4220
4221 static const ::Ice::ObjectFactoryPtr& ice_factory();
4222
4223protected:
4224
4225 virtual ~Request() {}
4226
4227public:
4228
4229 ::Ehr::AccountIdentifier requestor;
4230
4231 ::Ehr::Timestamp when;
4232};
4233
4234class ThirdPartyRequest : virtual public ::Ehr::Request
4235{
4236public:
4237
4238 typedef ThirdPartyRequestPrx ProxyType;
4239 typedef ThirdPartyRequestPtr PointerType;
4240
4241 ThirdPartyRequest() {}
4242 ThirdPartyRequest(const ::Ehr::AccountIdentifier&, const ::Ehr::Timestamp&, const ::Ehr::AccountIdentifier&);
4243 virtual ::Ice::ObjectPtr ice_clone() const;
4244
4245 virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
4246 virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
4247 virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
4248 static const ::std::string& ice_staticId();
4249
4250
4251 virtual void __write(::IceInternal::BasicStream*) const;
4252 virtual void __read(::IceInternal::BasicStream*, bool);
4253 virtual void __write(const ::Ice::OutputStreamPtr&) const;
4254 virtual void __read(const ::Ice::InputStreamPtr&, bool);
4255
4256 static const ::Ice::ObjectFactoryPtr& ice_factory();
4257
4258protected:
4259
4260 virtual ~ThirdPartyRequest() {}
4261
4262public:
4263
4264 ::Ehr::AccountIdentifier owner;
4265};
4266
4267class CreatePrescriptionRequest : virtual public ::Ehr::ThirdPartyRequest
4268{
4269public:
4270
4271 typedef CreatePrescriptionRequestPrx ProxyType;
4272 typedef CreatePrescriptionRequestPtr PointerType;
4273
4274 CreatePrescriptionRequest() {}
4275 CreatePrescriptionRequest(const ::Ehr::AccountIdentifier&, const ::Ehr::Timestamp&, const ::Ehr::AccountIdentifier&, const ::Ehr::EncryptedDocument&);
4276 virtual ::Ice::ObjectPtr ice_clone() const;
4277
4278 virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
4279 virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
4280 virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
4281 static const ::std::string& ice_staticId();
4282
4283
4284 virtual void __write(::IceInternal::BasicStream*) const;
4285 virtual void __read(::IceInternal::BasicStream*, bool);
4286 virtual void __write(const ::Ice::OutputStreamPtr&) const;
4287 virtual void __read(const ::Ice::InputStreamPtr&, bool);
4288
4289 static const ::Ice::ObjectFactoryPtr& ice_factory();
4290
4291protected:
4292
4293 virtual ~CreatePrescriptionRequest() {}
4294
4295public:
4296
4297 ::Ehr::EncryptedDocument prescription;
4298};
4299
4300class ConsumePrescriptionRequest : virtual public ::Ehr::ThirdPartyRequest
4301{
4302public:
4303
4304 typedef ConsumePrescriptionRequestPrx ProxyType;
4305 typedef ConsumePrescriptionRequestPtr PointerType;
4306
4307 ConsumePrescriptionRequest() {}
4308 ConsumePrescriptionRequest(const ::Ehr::AccountIdentifier&, const ::Ehr::Timestamp&, const ::Ehr::AccountIdentifier&, ::Ice::Long, const ::Ehr::EncryptedDocument&);
4309 virtual ::Ice::ObjectPtr ice_clone() const;
4310
4311 virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
4312 virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
4313 virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
4314 static const ::std::string& ice_staticId();
4315
4316
4317 virtual void __write(::IceInternal::BasicStream*) const;
4318 virtual void __read(::IceInternal::BasicStream*, bool);
4319 virtual void __write(const ::Ice::OutputStreamPtr&) const;
4320 virtual void __read(const ::Ice::InputStreamPtr&, bool);
4321
4322 static const ::Ice::ObjectFactoryPtr& ice_factory();
4323
4324protected:
4325
4326 virtual ~ConsumePrescriptionRequest() {}
4327
4328public:
4329
4330 ::Ice::Long prescriptionId;
4331
4332 ::Ehr::EncryptedDocument consumedPrescription;
4333};
4334
4335class ListDocumentsRequest : virtual public ::Ehr::ThirdPartyRequest
4336{
4337public:
4338
4339 typedef ListDocumentsRequestPrx ProxyType;
4340 typedef ListDocumentsRequestPtr PointerType;
4341
4342 ListDocumentsRequest() {}
4343 ListDocumentsRequest(const ::Ehr::AccountIdentifier&, const ::Ehr::Timestamp&, const ::Ehr::AccountIdentifier&);
4344 virtual ::Ice::ObjectPtr ice_clone() const;
4345
4346 virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
4347 virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
4348 virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
4349 static const ::std::string& ice_staticId();
4350
4351 virtual void __write(::IceInternal::BasicStream*) const;
4352 virtual void __read(::IceInternal::BasicStream*, bool);
4353 virtual void __write(const ::Ice::OutputStreamPtr&) const;
4354 virtual void __read(const ::Ice::InputStreamPtr&, bool);
4355
4356 static const ::Ice::ObjectFactoryPtr& ice_factory();
4357
4358protected:
4359
4360 virtual ~ListDocumentsRequest() {}
4361};
4362
4363class FindDocumentsRequest : virtual public ::Ehr::ThirdPartyRequest
4364{
4365public:
4366
4367 typedef FindDocumentsRequestPrx ProxyType;
4368 typedef FindDocumentsRequestPtr PointerType;
4369
4370 FindDocumentsRequest() {}
4371 FindDocumentsRequest(const ::Ehr::AccountIdentifier&, const ::Ehr::Timestamp&, const ::Ehr::AccountIdentifier&, bool, const ::Ehr::Timestamp&, bool, const ::Ehr::Timestamp&, ::Ehr::DocumentType, ::Ice::Long);
4372 virtual ::Ice::ObjectPtr ice_clone() const;
4373
4374 virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
4375 virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
4376 virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
4377 static const ::std::string& ice_staticId();
4378
4379
4380 virtual void __write(::IceInternal::BasicStream*) const;
4381 virtual void __read(::IceInternal::BasicStream*, bool);
4382 virtual void __write(const ::Ice::OutputStreamPtr&) const;
4383 virtual void __read(const ::Ice::InputStreamPtr&, bool);
4384
4385 static const ::Ice::ObjectFactoryPtr& ice_factory();
4386
4387protected:
4388
4389 virtual ~FindDocumentsRequest() {}
4390
4391public:
4392
4393 bool hasFrom;
4394
4395 ::Ehr::Timestamp from;
4396
4397 bool hasTill;
4398
4399 ::Ehr::Timestamp till;
4400
4401 ::Ehr::DocumentType type;
4402
4403 ::Ice::Long documentId;
4404};
4405
4406class CreatePermissionRequest : virtual public ::Ehr::Request
4407{
4408public:
4409
4410 typedef CreatePermissionRequestPrx ProxyType;
4411 typedef CreatePermissionRequestPtr PointerType;
4412
4413 CreatePermissionRequest() {}
4414 CreatePermissionRequest(const ::Ehr::AccountIdentifier&, const ::Ehr::Timestamp&, ::Ice::Long, const ::Ehr::AccountIdentifier&, ::Ehr::AccessType);
4415 virtual ::Ice::ObjectPtr ice_clone() const;
4416
4417 virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
4418 virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
4419 virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
4420 static const ::std::string& ice_staticId();
4421
4422
4423 virtual void __write(::IceInternal::BasicStream*) const;
4424 virtual void __read(::IceInternal::BasicStream*, bool);
4425 virtual void __write(const ::Ice::OutputStreamPtr&) const;
4426 virtual void __read(const ::Ice::InputStreamPtr&, bool);
4427
4428 static const ::Ice::ObjectFactoryPtr& ice_factory();
4429
4430protected:
4431
4432 virtual ~CreatePermissionRequest() {}
4433
4434public:
4435
4436 ::Ice::Long documentId;
4437
4438 ::Ehr::AccountIdentifier account;
4439
4440 ::Ehr::AccessType access;
4441};
4442
4443class SetDefaultAccessRequest : virtual public ::Ehr::Request
4444{
4445public:
4446
4447 typedef SetDefaultAccessRequestPrx ProxyType;
4448 typedef SetDefaultAccessRequestPtr PointerType;
4449
4450 SetDefaultAccessRequest() {}
4451 SetDefaultAccessRequest(const ::Ehr::AccountIdentifier&, const ::Ehr::Timestamp&, ::Ice::Long, ::Ehr::AccessType);
4452 virtual ::Ice::ObjectPtr ice_clone() const;
4453
4454 virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
4455 virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
4456 virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
4457 static const ::std::string& ice_staticId();
4458
4459
4460 virtual void __write(::IceInternal::BasicStream*) const;
4461 virtual void __read(::IceInternal::BasicStream*, bool);
4462 virtual void __write(const ::Ice::OutputStreamPtr&) const;
4463 virtual void __read(const ::Ice::InputStreamPtr&, bool);
4464
4465 static const ::Ice::ObjectFactoryPtr& ice_factory();
4466
4467protected:
4468
4469 virtual ~SetDefaultAccessRequest() {}
4470
4471public:
4472
4473 ::Ice::Long documentId;
4474
4475 ::Ehr::AccessType access;
4476};
4477
4478class ListPermissionsRequest : virtual public ::Ehr::Request
4479{
4480public:
4481
4482 typedef ListPermissionsRequestPrx ProxyType;
4483 typedef ListPermissionsRequestPtr PointerType;
4484
4485 ListPermissionsRequest() {}
4486 ListPermissionsRequest(const ::Ehr::AccountIdentifier&, const ::Ehr::Timestamp&, ::Ice::Long);
4487 virtual ::Ice::ObjectPtr ice_clone() const;
4488
4489 virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
4490 virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
4491 virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
4492 static const ::std::string& ice_staticId();
4493
4494
4495 virtual void __write(::IceInternal::BasicStream*) const;
4496 virtual void __read(::IceInternal::BasicStream*, bool);
4497 virtual void __write(const ::Ice::OutputStreamPtr&) const;
4498 virtual void __read(const ::Ice::InputStreamPtr&, bool);
4499
4500 static const ::Ice::ObjectFactoryPtr& ice_factory();
4501
4502protected:
4503
4504 virtual ~ListPermissionsRequest() {}
4505
4506public:
4507
4508 ::Ice::Long documentId;
4509};
4510
4511class RemovePermissionRequest : virtual public ::Ehr::Request
4512{
4513public:
4514
4515 typedef RemovePermissionRequestPrx ProxyType;
4516 typedef RemovePermissionRequestPtr PointerType;
4517
4518 RemovePermissionRequest() {}
4519 RemovePermissionRequest(const ::Ehr::AccountIdentifier&, const ::Ehr::Timestamp&, ::Ice::Long, ::Ice::Long);
4520 virtual ::Ice::ObjectPtr ice_clone() const;
4521
4522 virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
4523 virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
4524 virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
4525 static const ::std::string& ice_staticId();
4526
4527
4528 virtual void __write(::IceInternal::BasicStream*) const;
4529 virtual void __read(::IceInternal::BasicStream*, bool);
4530 virtual void __write(const ::Ice::OutputStreamPtr&) const;
4531 virtual void __read(const ::Ice::InputStreamPtr&, bool);
4532
4533 static const ::Ice::ObjectFactoryPtr& ice_factory();
4534
4535protected:
4536
4537 virtual ~RemovePermissionRequest() {}
4538
4539public:
4540
4541 ::Ice::Long documentId;
4542
4543 ::Ice::Long permissionId;
4544};
4545
4546class Provider : virtual public ::Ice::Object
4547{
4548public:
4549
4550 typedef ProviderPrx ProxyType;
4551 typedef ProviderPtr PointerType;
4552
4553 virtual ::Ice::ObjectPtr ice_clone() const;
4554
4555 virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
4556 virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
4557 virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
4558 static const ::std::string& ice_staticId();
4559
4560 virtual void createPrescription(const ::Ehr::CreatePrescriptionRequestPtr&, const ::Ehr::Signature&, const ::Ehr::Signature&, const ::Ice::Current& = ::Ice::Current()) = 0;
4561 ::Ice::DispatchStatus ___createPrescription(::IceInternal::Incoming&, const ::Ice::Current&);
4562
4563 virtual void consumePrescription(const ::Ehr::ConsumePrescriptionRequestPtr&, const ::Ehr::Signature&, const ::Ehr::Signature&, const ::Ice::Current& = ::Ice::Current()) = 0;
4564 ::Ice::DispatchStatus ___consumePrescription(::IceInternal::Incoming&, const ::Ice::Current&);
4565
4566 virtual ::Ehr::DocumentList listDocuments(const ::Ehr::ListDocumentsRequestPtr&, const ::Ehr::Signature&, const ::Ehr::Signature&, const ::Ice::Current& = ::Ice::Current()) = 0;
4567 ::Ice::DispatchStatus ___listDocuments(::IceInternal::Incoming&, const ::Ice::Current&);
4568
4569 virtual ::Ehr::DocumentList findDocuments(const ::Ehr::FindDocumentsRequestPtr&, const ::Ehr::Signature&, const ::Ehr::Signature&, const ::Ice::Current& = ::Ice::Current()) = 0;
4570 ::Ice::DispatchStatus ___findDocuments(::IceInternal::Incoming&, const ::Ice::Current&);
4571
4572 virtual void setDefaultAccess(const ::Ehr::SetDefaultAccessRequestPtr&, const ::Ehr::Signature&, const ::Ice::Current& = ::Ice::Current()) = 0;
4573 ::Ice::DispatchStatus ___setDefaultAccess(::IceInternal::Incoming&, const ::Ice::Current&);
4574
4575 virtual void createPermission(const ::Ehr::CreatePermissionRequestPtr&, const ::Ehr::Signature&, const ::Ice::Current& = ::Ice::Current()) = 0;
4576 ::Ice::DispatchStatus ___createPermission(::IceInternal::Incoming&, const ::Ice::Current&);
4577
4578 virtual ::Ehr::Permissions listPermissions(const ::Ehr::ListPermissionsRequestPtr&, const ::Ehr::Signature&, const ::Ice::Current& = ::Ice::Current()) = 0;
4579 ::Ice::DispatchStatus ___listPermissions(::IceInternal::Incoming&, const ::Ice::Current&);
4580
4581 virtual void removePermission(const ::Ehr::RemovePermissionRequestPtr&, const ::Ehr::Signature&, const ::Ice::Current& = ::Ice::Current()) = 0;
4582 ::Ice::DispatchStatus ___removePermission(::IceInternal::Incoming&, const ::Ice::Current&);
4583
4584 virtual ::Ice::DispatchStatus __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);
4585
4586 virtual void __write(::IceInternal::BasicStream*) const;
4587 virtual void __read(::IceInternal::BasicStream*, bool);
4588 virtual void __write(const ::Ice::OutputStreamPtr&) const;
4589 virtual void __read(const ::Ice::InputStreamPtr&, bool);
4590};
4591
4592}
4593
4594#endif
generated by cgit v1.2.3 (git 2.25.1) at 2026-01-11 16:00:15 +0000